Separate egress/ingress storage (#855)

2026-05-14 18:25:24 +00:00 · 2022-07-28 17:01:33 -05:00
parent 7a2eac8e86
commit 0ab4379c5c
10 changed files with 982 additions and 1734 deletions
@@ -235,8 +235,6 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/lithammer/shortuuid/v3 v3.0.7 h1:trX0KTHy4Pbwo/6ia8fscyHoGA+mf1jWbPJVuvyJQQ8=
 github.com/lithammer/shortuuid/v3 v3.0.7/go.mod h1:vMk8ke37EmiewwolSO1NLW8vP4ZaKlRuDIi8tWWmAts=
-github.com/livekit/protocol v0.13.5-0.20220726184153-ad9c55ddef52 h1:E0trQ3RLu2b9hjSiJG1+1hyK/8v57NPJznA7/lKj0qY=
-github.com/livekit/protocol v0.13.5-0.20220726184153-ad9c55ddef52/go.mod h1:Qd/Dn4BkJfZQy/IjtEeUOGXARrR7l09WDkg5SY8thkw=
 github.com/livekit/protocol v0.13.5-0.20220727215941-ac26418a52e9 h1:e12j1EyiiTG56Ag44fwpVtnYQ6MVgLv4bYYI0nTgxZY=
 github.com/livekit/protocol v0.13.5-0.20220727215941-ac26418a52e9/go.mod h1:Qd/Dn4BkJfZQy/IjtEeUOGXARrR7l09WDkg5SY8thkw=
 github.com/livekit/rtcscore-go v0.0.0-20220524203225-dfd1ba40744a h1:cENjhGfslLSDV07gt8ASy47Wd12Q0kBS7hsdunyQ62I=
@@ -17,6 +17,7 @@ import (
 type EgressService struct {
 	rpcClient   egress.RPCClient
 	store       ServiceStore
+	es          EgressStore
 	roomService livekit.RoomService
 	telemetry   telemetry.TelemetryService
 	shutdown    chan struct{}
@@ -25,6 +26,7 @@ type EgressService struct {
 func NewEgressService(
 	rpcClient egress.RPCClient,
 	store ServiceStore,
+	es EgressStore,
 	rs livekit.RoomService,
 	ts telemetry.TelemetryService,
 ) *EgressService {
@@ -32,6 +34,7 @@ func NewEgressService(
 	return &EgressService{
 		rpcClient:   rpcClient,
 		store:       store,
+		es:          es,
 		roomService: rs,
 		telemetry:   ts,
 		shutdown:    make(chan struct{}),
@@ -93,7 +96,7 @@ func (s *EgressService) StartEgress(ctx context.Context, roomName livekit.RoomNa

 	s.telemetry.EgressStarted(ctx, info)
 	go func() {
-		if err := s.store.StoreEgress(ctx, info); err != nil {
+		if err := s.es.StoreEgress(ctx, info); err != nil {
 			logger.Errorw("could not write egress info", err)
 		}
 	}()
@@ -113,7 +116,7 @@ func (s *EgressService) UpdateLayout(ctx context.Context, req *livekit.UpdateLay
 		return nil, ErrEgressNotConnected
 	}

-	info, err := s.store.LoadEgress(ctx, req.EgressId)
+	info, err := s.es.LoadEgress(ctx, req.EgressId)
 	if err != nil {
 		return nil, err
 	}
@@ -170,7 +173,7 @@ func (s *EgressService) UpdateStream(ctx context.Context, req *livekit.UpdateStr
 	}

 	go func() {
-		if err := s.store.UpdateEgress(ctx, info); err != nil {
+		if err := s.es.UpdateEgress(ctx, info); err != nil {
 			logger.Errorw("could not write egress info", err)
 		}
 	}()
@@ -198,7 +201,7 @@ func (s *EgressService) ListEgress(ctx context.Context, req *livekit.ListEgressR
 		roomID = livekit.RoomID(room.Sid)
 	}

-	infos, err := s.store.ListEgress(ctx, roomID)
+	infos, err := s.es.ListEgress(ctx, roomID)
 	if err != nil {
 		return nil, err
 	}
@@ -225,7 +228,7 @@ func (s *EgressService) StopEgress(ctx context.Context, req *livekit.StopEgressR
 	}

 	go func() {
-		if err := s.store.UpdateEgress(ctx, info); err != nil {
+		if err := s.es.UpdateEgress(ctx, info); err != nil {
 			logger.Errorw("could not write egress info", err)
 		}
 	}()
@@ -257,7 +260,7 @@ func (s *EgressService) updateWorker() {
 				livekit.EgressStatus_EGRESS_ENDING:

 				// save updated info to store
-				err = s.store.UpdateEgress(context.Background(), res)
+				err = s.es.UpdateEgress(context.Background(), res)
 				if err != nil {
 					logger.Errorw("could not update egress", err)
 				}
@@ -267,7 +270,7 @@ func (s *EgressService) updateWorker() {
 				livekit.EgressStatus_EGRESS_ABORTED:

 				// delete from store
-				err = s.store.DeleteEgress(context.Background(), res)
+				err = s.es.DeleteEgress(context.Background(), res)
 				if err != nil {
 					logger.Errorw("could not delete egress from store", err)
 				}
@@ -14,7 +14,7 @@ import (

 type IngressService struct {
 	rpc         ingress.RPC
-	store       ServiceStore
+	store       IngressStore
 	roomService livekit.RoomService
 	telemetry   telemetry.TelemetryService
 	shutdown    chan struct{}
@@ -22,7 +22,7 @@ type IngressService struct {

 func NewIngressService(
 	rpc ingress.RPC,
-	store ServiceStore,
+	store IngressStore,
 	rs livekit.RoomService,
 	ts telemetry.TelemetryService,
 ) *IngressService {
@@ -35,13 +35,19 @@ type ServiceStore interface {

 	LoadParticipant(ctx context.Context, roomName livekit.RoomName, identity livekit.ParticipantIdentity) (*livekit.ParticipantInfo, error)
 	ListParticipants(ctx context.Context, roomName livekit.RoomName) ([]*livekit.ParticipantInfo, error)
+}

+//counterfeiter:generate . EgressStore
+type EgressStore interface {
 	StoreEgress(ctx context.Context, info *livekit.EgressInfo) error
 	LoadEgress(ctx context.Context, egressID string) (*livekit.EgressInfo, error)
 	ListEgress(ctx context.Context, roomID livekit.RoomID) ([]*livekit.EgressInfo, error)
 	UpdateEgress(ctx context.Context, info *livekit.EgressInfo) error
 	DeleteEgress(ctx context.Context, info *livekit.EgressInfo) error
+}

+//counterfeiter:generate . IngressStore
+type IngressStore interface {
 	StoreIngress(ctx context.Context, info *livekit.IngressInfo) error
 	LoadIngress(ctx context.Context, ingressID string) (*livekit.IngressInfo, error)
 	LoadIngressFromStreamKey(ctx context.Context, streamKey string) (*livekit.IngressInfo, error)
@@ -0,0 +1,429 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package servicefakes
+
+import (
+	"context"
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/service"
+	"github.com/livekit/protocol/livekit"
+)
+
+type FakeEgressStore struct {
+	DeleteEgressStub        func(context.Context, *livekit.EgressInfo) error
+	deleteEgressMutex       sync.RWMutex
+	deleteEgressArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.EgressInfo
+	}
+	deleteEgressReturns struct {
+		result1 error
+	}
+	deleteEgressReturnsOnCall map[int]struct {
+		result1 error
+	}
+	ListEgressStub        func(context.Context, livekit.RoomID) ([]*livekit.EgressInfo, error)
+	listEgressMutex       sync.RWMutex
+	listEgressArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomID
+	}
+	listEgressReturns struct {
+		result1 []*livekit.EgressInfo
+		result2 error
+	}
+	listEgressReturnsOnCall map[int]struct {
+		result1 []*livekit.EgressInfo
+		result2 error
+	}
+	LoadEgressStub        func(context.Context, string) (*livekit.EgressInfo, error)
+	loadEgressMutex       sync.RWMutex
+	loadEgressArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+	}
+	loadEgressReturns struct {
+		result1 *livekit.EgressInfo
+		result2 error
+	}
+	loadEgressReturnsOnCall map[int]struct {
+		result1 *livekit.EgressInfo
+		result2 error
+	}
+	StoreEgressStub        func(context.Context, *livekit.EgressInfo) error
+	storeEgressMutex       sync.RWMutex
+	storeEgressArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.EgressInfo
+	}
+	storeEgressReturns struct {
+		result1 error
+	}
+	storeEgressReturnsOnCall map[int]struct {
+		result1 error
+	}
+	UpdateEgressStub        func(context.Context, *livekit.EgressInfo) error
+	updateEgressMutex       sync.RWMutex
+	updateEgressArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.EgressInfo
+	}
+	updateEgressReturns struct {
+		result1 error
+	}
+	updateEgressReturnsOnCall map[int]struct {
+		result1 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeEgressStore) DeleteEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error {
+	fake.deleteEgressMutex.Lock()
+	ret, specificReturn := fake.deleteEgressReturnsOnCall[len(fake.deleteEgressArgsForCall)]
+	fake.deleteEgressArgsForCall = append(fake.deleteEgressArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.EgressInfo
+	}{arg1, arg2})
+	stub := fake.DeleteEgressStub
+	fakeReturns := fake.deleteEgressReturns
+	fake.recordInvocation("DeleteEgress", []interface{}{arg1, arg2})
+	fake.deleteEgressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeEgressStore) DeleteEgressCallCount() int {
+	fake.deleteEgressMutex.RLock()
+	defer fake.deleteEgressMutex.RUnlock()
+	return len(fake.deleteEgressArgsForCall)
+}
+
+func (fake *FakeEgressStore) DeleteEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) {
+	fake.deleteEgressMutex.Lock()
+	defer fake.deleteEgressMutex.Unlock()
+	fake.DeleteEgressStub = stub
+}
+
+func (fake *FakeEgressStore) DeleteEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) {
+	fake.deleteEgressMutex.RLock()
+	defer fake.deleteEgressMutex.RUnlock()
+	argsForCall := fake.deleteEgressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeEgressStore) DeleteEgressReturns(result1 error) {
+	fake.deleteEgressMutex.Lock()
+	defer fake.deleteEgressMutex.Unlock()
+	fake.DeleteEgressStub = nil
+	fake.deleteEgressReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeEgressStore) DeleteEgressReturnsOnCall(i int, result1 error) {
+	fake.deleteEgressMutex.Lock()
+	defer fake.deleteEgressMutex.Unlock()
+	fake.DeleteEgressStub = nil
+	if fake.deleteEgressReturnsOnCall == nil {
+		fake.deleteEgressReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.deleteEgressReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeEgressStore) ListEgress(arg1 context.Context, arg2 livekit.RoomID) ([]*livekit.EgressInfo, error) {
+	fake.listEgressMutex.Lock()
+	ret, specificReturn := fake.listEgressReturnsOnCall[len(fake.listEgressArgsForCall)]
+	fake.listEgressArgsForCall = append(fake.listEgressArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomID
+	}{arg1, arg2})
+	stub := fake.ListEgressStub
+	fakeReturns := fake.listEgressReturns
+	fake.recordInvocation("ListEgress", []interface{}{arg1, arg2})
+	fake.listEgressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeEgressStore) ListEgressCallCount() int {
+	fake.listEgressMutex.RLock()
+	defer fake.listEgressMutex.RUnlock()
+	return len(fake.listEgressArgsForCall)
+}
+
+func (fake *FakeEgressStore) ListEgressCalls(stub func(context.Context, livekit.RoomID) ([]*livekit.EgressInfo, error)) {
+	fake.listEgressMutex.Lock()
+	defer fake.listEgressMutex.Unlock()
+	fake.ListEgressStub = stub
+}
+
+func (fake *FakeEgressStore) ListEgressArgsForCall(i int) (context.Context, livekit.RoomID) {
+	fake.listEgressMutex.RLock()
+	defer fake.listEgressMutex.RUnlock()
+	argsForCall := fake.listEgressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeEgressStore) ListEgressReturns(result1 []*livekit.EgressInfo, result2 error) {
+	fake.listEgressMutex.Lock()
+	defer fake.listEgressMutex.Unlock()
+	fake.ListEgressStub = nil
+	fake.listEgressReturns = struct {
+		result1 []*livekit.EgressInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeEgressStore) ListEgressReturnsOnCall(i int, result1 []*livekit.EgressInfo, result2 error) {
+	fake.listEgressMutex.Lock()
+	defer fake.listEgressMutex.Unlock()
+	fake.ListEgressStub = nil
+	if fake.listEgressReturnsOnCall == nil {
+		fake.listEgressReturnsOnCall = make(map[int]struct {
+			result1 []*livekit.EgressInfo
+			result2 error
+		})
+	}
+	fake.listEgressReturnsOnCall[i] = struct {
+		result1 []*livekit.EgressInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeEgressStore) LoadEgress(arg1 context.Context, arg2 string) (*livekit.EgressInfo, error) {
+	fake.loadEgressMutex.Lock()
+	ret, specificReturn := fake.loadEgressReturnsOnCall[len(fake.loadEgressArgsForCall)]
+	fake.loadEgressArgsForCall = append(fake.loadEgressArgsForCall, struct {
+		arg1 context.Context
+		arg2 string
+	}{arg1, arg2})
+	stub := fake.LoadEgressStub
+	fakeReturns := fake.loadEgressReturns
+	fake.recordInvocation("LoadEgress", []interface{}{arg1, arg2})
+	fake.loadEgressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeEgressStore) LoadEgressCallCount() int {
+	fake.loadEgressMutex.RLock()
+	defer fake.loadEgressMutex.RUnlock()
+	return len(fake.loadEgressArgsForCall)
+}
+
+func (fake *FakeEgressStore) LoadEgressCalls(stub func(context.Context, string) (*livekit.EgressInfo, error)) {
+	fake.loadEgressMutex.Lock()
+	defer fake.loadEgressMutex.Unlock()
+	fake.LoadEgressStub = stub
+}
+
+func (fake *FakeEgressStore) LoadEgressArgsForCall(i int) (context.Context, string) {
+	fake.loadEgressMutex.RLock()
+	defer fake.loadEgressMutex.RUnlock()
+	argsForCall := fake.loadEgressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeEgressStore) LoadEgressReturns(result1 *livekit.EgressInfo, result2 error) {
+	fake.loadEgressMutex.Lock()
+	defer fake.loadEgressMutex.Unlock()
+	fake.LoadEgressStub = nil
+	fake.loadEgressReturns = struct {
+		result1 *livekit.EgressInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeEgressStore) LoadEgressReturnsOnCall(i int, result1 *livekit.EgressInfo, result2 error) {
+	fake.loadEgressMutex.Lock()
+	defer fake.loadEgressMutex.Unlock()
+	fake.LoadEgressStub = nil
+	if fake.loadEgressReturnsOnCall == nil {
+		fake.loadEgressReturnsOnCall = make(map[int]struct {
+			result1 *livekit.EgressInfo
+			result2 error
+		})
+	}
+	fake.loadEgressReturnsOnCall[i] = struct {
+		result1 *livekit.EgressInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeEgressStore) StoreEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error {
+	fake.storeEgressMutex.Lock()
+	ret, specificReturn := fake.storeEgressReturnsOnCall[len(fake.storeEgressArgsForCall)]
+	fake.storeEgressArgsForCall = append(fake.storeEgressArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.EgressInfo
+	}{arg1, arg2})
+	stub := fake.StoreEgressStub
+	fakeReturns := fake.storeEgressReturns
+	fake.recordInvocation("StoreEgress", []interface{}{arg1, arg2})
+	fake.storeEgressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeEgressStore) StoreEgressCallCount() int {
+	fake.storeEgressMutex.RLock()
+	defer fake.storeEgressMutex.RUnlock()
+	return len(fake.storeEgressArgsForCall)
+}
+
+func (fake *FakeEgressStore) StoreEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) {
+	fake.storeEgressMutex.Lock()
+	defer fake.storeEgressMutex.Unlock()
+	fake.StoreEgressStub = stub
+}
+
+func (fake *FakeEgressStore) StoreEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) {
+	fake.storeEgressMutex.RLock()
+	defer fake.storeEgressMutex.RUnlock()
+	argsForCall := fake.storeEgressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeEgressStore) StoreEgressReturns(result1 error) {
+	fake.storeEgressMutex.Lock()
+	defer fake.storeEgressMutex.Unlock()
+	fake.StoreEgressStub = nil
+	fake.storeEgressReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeEgressStore) StoreEgressReturnsOnCall(i int, result1 error) {
+	fake.storeEgressMutex.Lock()
+	defer fake.storeEgressMutex.Unlock()
+	fake.StoreEgressStub = nil
+	if fake.storeEgressReturnsOnCall == nil {
+		fake.storeEgressReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.storeEgressReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeEgressStore) UpdateEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error {
+	fake.updateEgressMutex.Lock()
+	ret, specificReturn := fake.updateEgressReturnsOnCall[len(fake.updateEgressArgsForCall)]
+	fake.updateEgressArgsForCall = append(fake.updateEgressArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.EgressInfo
+	}{arg1, arg2})
+	stub := fake.UpdateEgressStub
+	fakeReturns := fake.updateEgressReturns
+	fake.recordInvocation("UpdateEgress", []interface{}{arg1, arg2})
+	fake.updateEgressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeEgressStore) UpdateEgressCallCount() int {
+	fake.updateEgressMutex.RLock()
+	defer fake.updateEgressMutex.RUnlock()
+	return len(fake.updateEgressArgsForCall)
+}
+
+func (fake *FakeEgressStore) UpdateEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) {
+	fake.updateEgressMutex.Lock()
+	defer fake.updateEgressMutex.Unlock()
+	fake.UpdateEgressStub = stub
+}
+
+func (fake *FakeEgressStore) UpdateEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) {
+	fake.updateEgressMutex.RLock()
+	defer fake.updateEgressMutex.RUnlock()
+	argsForCall := fake.updateEgressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeEgressStore) UpdateEgressReturns(result1 error) {
+	fake.updateEgressMutex.Lock()
+	defer fake.updateEgressMutex.Unlock()
+	fake.UpdateEgressStub = nil
+	fake.updateEgressReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeEgressStore) UpdateEgressReturnsOnCall(i int, result1 error) {
+	fake.updateEgressMutex.Lock()
+	defer fake.updateEgressMutex.Unlock()
+	fake.UpdateEgressStub = nil
+	if fake.updateEgressReturnsOnCall == nil {
+		fake.updateEgressReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.updateEgressReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeEgressStore) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	fake.deleteEgressMutex.RLock()
+	defer fake.deleteEgressMutex.RUnlock()
+	fake.listEgressMutex.RLock()
+	defer fake.listEgressMutex.RUnlock()
+	fake.loadEgressMutex.RLock()
+	defer fake.loadEgressMutex.RUnlock()
+	fake.storeEgressMutex.RLock()
+	defer fake.storeEgressMutex.RUnlock()
+	fake.updateEgressMutex.RLock()
+	defer fake.updateEgressMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeEgressStore) recordInvocation(key string, args []interface{}) {
+	fake.invocationsMutex.Lock()
+	defer fake.invocationsMutex.Unlock()
+	if fake.invocations == nil {
+		fake.invocations = map[string][][]interface{}{}
+	}
+	if fake.invocations[key] == nil {
+		fake.invocations[key] = [][]interface{}{}
+	}
+	fake.invocations[key] = append(fake.invocations[key], args)
+}
+
+var _ service.EgressStore = new(FakeEgressStore)
@@ -0,0 +1,510 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package servicefakes
+
+import (
+	"context"
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/service"
+	"github.com/livekit/protocol/livekit"
+)
+
+type FakeIngressStore struct {
+	DeleteIngressStub        func(context.Context, *livekit.IngressInfo) error
+	deleteIngressMutex       sync.RWMutex
+	deleteIngressArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.IngressInfo
+	}
+	deleteIngressReturns struct {
+		result1 error
+	}
+	deleteIngressReturnsOnCall map[int]struct {
+		result1 error
+	}
+	ListIngressStub        func(context.Context, livekit.RoomName) ([]*livekit.IngressInfo, error)
+	listIngressMutex       sync.RWMutex
+	listIngressArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}
+	listIngressReturns struct {
+		result1 []*livekit.IngressInfo
+		result2 error
+	}
+	listIngressReturnsOnCall map[int]struct {
+		result1 []*livekit.IngressInfo
+		result2 error
+	}
+	LoadIngressStub        func(context.Context, string) (*livekit.IngressInfo, error)
+	loadIngressMutex       sync.RWMutex
+	loadIngressArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+	}
+	loadIngressReturns struct {
+		result1 *livekit.IngressInfo
+		result2 error
+	}
+	loadIngressReturnsOnCall map[int]struct {
+		result1 *livekit.IngressInfo
+		result2 error
+	}
+	LoadIngressFromStreamKeyStub        func(context.Context, string) (*livekit.IngressInfo, error)
+	loadIngressFromStreamKeyMutex       sync.RWMutex
+	loadIngressFromStreamKeyArgsForCall []struct {
+		arg1 context.Context
+		arg2 string
+	}
+	loadIngressFromStreamKeyReturns struct {
+		result1 *livekit.IngressInfo
+		result2 error
+	}
+	loadIngressFromStreamKeyReturnsOnCall map[int]struct {
+		result1 *livekit.IngressInfo
+		result2 error
+	}
+	StoreIngressStub        func(context.Context, *livekit.IngressInfo) error
+	storeIngressMutex       sync.RWMutex
+	storeIngressArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.IngressInfo
+	}
+	storeIngressReturns struct {
+		result1 error
+	}
+	storeIngressReturnsOnCall map[int]struct {
+		result1 error
+	}
+	UpdateIngressStub        func(context.Context, *livekit.IngressInfo) error
+	updateIngressMutex       sync.RWMutex
+	updateIngressArgsForCall []struct {
+		arg1 context.Context
+		arg2 *livekit.IngressInfo
+	}
+	updateIngressReturns struct {
+		result1 error
+	}
+	updateIngressReturnsOnCall map[int]struct {
+		result1 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeIngressStore) DeleteIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error {
+	fake.deleteIngressMutex.Lock()
+	ret, specificReturn := fake.deleteIngressReturnsOnCall[len(fake.deleteIngressArgsForCall)]
+	fake.deleteIngressArgsForCall = append(fake.deleteIngressArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.IngressInfo
+	}{arg1, arg2})
+	stub := fake.DeleteIngressStub
+	fakeReturns := fake.deleteIngressReturns
+	fake.recordInvocation("DeleteIngress", []interface{}{arg1, arg2})
+	fake.deleteIngressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeIngressStore) DeleteIngressCallCount() int {
+	fake.deleteIngressMutex.RLock()
+	defer fake.deleteIngressMutex.RUnlock()
+	return len(fake.deleteIngressArgsForCall)
+}
+
+func (fake *FakeIngressStore) DeleteIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) {
+	fake.deleteIngressMutex.Lock()
+	defer fake.deleteIngressMutex.Unlock()
+	fake.DeleteIngressStub = stub
+}
+
+func (fake *FakeIngressStore) DeleteIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) {
+	fake.deleteIngressMutex.RLock()
+	defer fake.deleteIngressMutex.RUnlock()
+	argsForCall := fake.deleteIngressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeIngressStore) DeleteIngressReturns(result1 error) {
+	fake.deleteIngressMutex.Lock()
+	defer fake.deleteIngressMutex.Unlock()
+	fake.DeleteIngressStub = nil
+	fake.deleteIngressReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeIngressStore) DeleteIngressReturnsOnCall(i int, result1 error) {
+	fake.deleteIngressMutex.Lock()
+	defer fake.deleteIngressMutex.Unlock()
+	fake.DeleteIngressStub = nil
+	if fake.deleteIngressReturnsOnCall == nil {
+		fake.deleteIngressReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.deleteIngressReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeIngressStore) ListIngress(arg1 context.Context, arg2 livekit.RoomName) ([]*livekit.IngressInfo, error) {
+	fake.listIngressMutex.Lock()
+	ret, specificReturn := fake.listIngressReturnsOnCall[len(fake.listIngressArgsForCall)]
+	fake.listIngressArgsForCall = append(fake.listIngressArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}{arg1, arg2})
+	stub := fake.ListIngressStub
+	fakeReturns := fake.listIngressReturns
+	fake.recordInvocation("ListIngress", []interface{}{arg1, arg2})
+	fake.listIngressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeIngressStore) ListIngressCallCount() int {
+	fake.listIngressMutex.RLock()
+	defer fake.listIngressMutex.RUnlock()
+	return len(fake.listIngressArgsForCall)
+}
+
+func (fake *FakeIngressStore) ListIngressCalls(stub func(context.Context, livekit.RoomName) ([]*livekit.IngressInfo, error)) {
+	fake.listIngressMutex.Lock()
+	defer fake.listIngressMutex.Unlock()
+	fake.ListIngressStub = stub
+}
+
+func (fake *FakeIngressStore) ListIngressArgsForCall(i int) (context.Context, livekit.RoomName) {
+	fake.listIngressMutex.RLock()
+	defer fake.listIngressMutex.RUnlock()
+	argsForCall := fake.listIngressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeIngressStore) ListIngressReturns(result1 []*livekit.IngressInfo, result2 error) {
+	fake.listIngressMutex.Lock()
+	defer fake.listIngressMutex.Unlock()
+	fake.ListIngressStub = nil
+	fake.listIngressReturns = struct {
+		result1 []*livekit.IngressInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIngressStore) ListIngressReturnsOnCall(i int, result1 []*livekit.IngressInfo, result2 error) {
+	fake.listIngressMutex.Lock()
+	defer fake.listIngressMutex.Unlock()
+	fake.ListIngressStub = nil
+	if fake.listIngressReturnsOnCall == nil {
+		fake.listIngressReturnsOnCall = make(map[int]struct {
+			result1 []*livekit.IngressInfo
+			result2 error
+		})
+	}
+	fake.listIngressReturnsOnCall[i] = struct {
+		result1 []*livekit.IngressInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIngressStore) LoadIngress(arg1 context.Context, arg2 string) (*livekit.IngressInfo, error) {
+	fake.loadIngressMutex.Lock()
+	ret, specificReturn := fake.loadIngressReturnsOnCall[len(fake.loadIngressArgsForCall)]
+	fake.loadIngressArgsForCall = append(fake.loadIngressArgsForCall, struct {
+		arg1 context.Context
+		arg2 string
+	}{arg1, arg2})
+	stub := fake.LoadIngressStub
+	fakeReturns := fake.loadIngressReturns
+	fake.recordInvocation("LoadIngress", []interface{}{arg1, arg2})
+	fake.loadIngressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeIngressStore) LoadIngressCallCount() int {
+	fake.loadIngressMutex.RLock()
+	defer fake.loadIngressMutex.RUnlock()
+	return len(fake.loadIngressArgsForCall)
+}
+
+func (fake *FakeIngressStore) LoadIngressCalls(stub func(context.Context, string) (*livekit.IngressInfo, error)) {
+	fake.loadIngressMutex.Lock()
+	defer fake.loadIngressMutex.Unlock()
+	fake.LoadIngressStub = stub
+}
+
+func (fake *FakeIngressStore) LoadIngressArgsForCall(i int) (context.Context, string) {
+	fake.loadIngressMutex.RLock()
+	defer fake.loadIngressMutex.RUnlock()
+	argsForCall := fake.loadIngressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeIngressStore) LoadIngressReturns(result1 *livekit.IngressInfo, result2 error) {
+	fake.loadIngressMutex.Lock()
+	defer fake.loadIngressMutex.Unlock()
+	fake.LoadIngressStub = nil
+	fake.loadIngressReturns = struct {
+		result1 *livekit.IngressInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIngressStore) LoadIngressReturnsOnCall(i int, result1 *livekit.IngressInfo, result2 error) {
+	fake.loadIngressMutex.Lock()
+	defer fake.loadIngressMutex.Unlock()
+	fake.LoadIngressStub = nil
+	if fake.loadIngressReturnsOnCall == nil {
+		fake.loadIngressReturnsOnCall = make(map[int]struct {
+			result1 *livekit.IngressInfo
+			result2 error
+		})
+	}
+	fake.loadIngressReturnsOnCall[i] = struct {
+		result1 *livekit.IngressInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIngressStore) LoadIngressFromStreamKey(arg1 context.Context, arg2 string) (*livekit.IngressInfo, error) {
+	fake.loadIngressFromStreamKeyMutex.Lock()
+	ret, specificReturn := fake.loadIngressFromStreamKeyReturnsOnCall[len(fake.loadIngressFromStreamKeyArgsForCall)]
+	fake.loadIngressFromStreamKeyArgsForCall = append(fake.loadIngressFromStreamKeyArgsForCall, struct {
+		arg1 context.Context
+		arg2 string
+	}{arg1, arg2})
+	stub := fake.LoadIngressFromStreamKeyStub
+	fakeReturns := fake.loadIngressFromStreamKeyReturns
+	fake.recordInvocation("LoadIngressFromStreamKey", []interface{}{arg1, arg2})
+	fake.loadIngressFromStreamKeyMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeIngressStore) LoadIngressFromStreamKeyCallCount() int {
+	fake.loadIngressFromStreamKeyMutex.RLock()
+	defer fake.loadIngressFromStreamKeyMutex.RUnlock()
+	return len(fake.loadIngressFromStreamKeyArgsForCall)
+}
+
+func (fake *FakeIngressStore) LoadIngressFromStreamKeyCalls(stub func(context.Context, string) (*livekit.IngressInfo, error)) {
+	fake.loadIngressFromStreamKeyMutex.Lock()
+	defer fake.loadIngressFromStreamKeyMutex.Unlock()
+	fake.LoadIngressFromStreamKeyStub = stub
+}
+
+func (fake *FakeIngressStore) LoadIngressFromStreamKeyArgsForCall(i int) (context.Context, string) {
+	fake.loadIngressFromStreamKeyMutex.RLock()
+	defer fake.loadIngressFromStreamKeyMutex.RUnlock()
+	argsForCall := fake.loadIngressFromStreamKeyArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeIngressStore) LoadIngressFromStreamKeyReturns(result1 *livekit.IngressInfo, result2 error) {
+	fake.loadIngressFromStreamKeyMutex.Lock()
+	defer fake.loadIngressFromStreamKeyMutex.Unlock()
+	fake.LoadIngressFromStreamKeyStub = nil
+	fake.loadIngressFromStreamKeyReturns = struct {
+		result1 *livekit.IngressInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIngressStore) LoadIngressFromStreamKeyReturnsOnCall(i int, result1 *livekit.IngressInfo, result2 error) {
+	fake.loadIngressFromStreamKeyMutex.Lock()
+	defer fake.loadIngressFromStreamKeyMutex.Unlock()
+	fake.LoadIngressFromStreamKeyStub = nil
+	if fake.loadIngressFromStreamKeyReturnsOnCall == nil {
+		fake.loadIngressFromStreamKeyReturnsOnCall = make(map[int]struct {
+			result1 *livekit.IngressInfo
+			result2 error
+		})
+	}
+	fake.loadIngressFromStreamKeyReturnsOnCall[i] = struct {
+		result1 *livekit.IngressInfo
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeIngressStore) StoreIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error {
+	fake.storeIngressMutex.Lock()
+	ret, specificReturn := fake.storeIngressReturnsOnCall[len(fake.storeIngressArgsForCall)]
+	fake.storeIngressArgsForCall = append(fake.storeIngressArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.IngressInfo
+	}{arg1, arg2})
+	stub := fake.StoreIngressStub
+	fakeReturns := fake.storeIngressReturns
+	fake.recordInvocation("StoreIngress", []interface{}{arg1, arg2})
+	fake.storeIngressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeIngressStore) StoreIngressCallCount() int {
+	fake.storeIngressMutex.RLock()
+	defer fake.storeIngressMutex.RUnlock()
+	return len(fake.storeIngressArgsForCall)
+}
+
+func (fake *FakeIngressStore) StoreIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) {
+	fake.storeIngressMutex.Lock()
+	defer fake.storeIngressMutex.Unlock()
+	fake.StoreIngressStub = stub
+}
+
+func (fake *FakeIngressStore) StoreIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) {
+	fake.storeIngressMutex.RLock()
+	defer fake.storeIngressMutex.RUnlock()
+	argsForCall := fake.storeIngressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeIngressStore) StoreIngressReturns(result1 error) {
+	fake.storeIngressMutex.Lock()
+	defer fake.storeIngressMutex.Unlock()
+	fake.StoreIngressStub = nil
+	fake.storeIngressReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeIngressStore) StoreIngressReturnsOnCall(i int, result1 error) {
+	fake.storeIngressMutex.Lock()
+	defer fake.storeIngressMutex.Unlock()
+	fake.StoreIngressStub = nil
+	if fake.storeIngressReturnsOnCall == nil {
+		fake.storeIngressReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.storeIngressReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeIngressStore) UpdateIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error {
+	fake.updateIngressMutex.Lock()
+	ret, specificReturn := fake.updateIngressReturnsOnCall[len(fake.updateIngressArgsForCall)]
+	fake.updateIngressArgsForCall = append(fake.updateIngressArgsForCall, struct {
+		arg1 context.Context
+		arg2 *livekit.IngressInfo
+	}{arg1, arg2})
+	stub := fake.UpdateIngressStub
+	fakeReturns := fake.updateIngressReturns
+	fake.recordInvocation("UpdateIngress", []interface{}{arg1, arg2})
+	fake.updateIngressMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeIngressStore) UpdateIngressCallCount() int {
+	fake.updateIngressMutex.RLock()
+	defer fake.updateIngressMutex.RUnlock()
+	return len(fake.updateIngressArgsForCall)
+}
+
+func (fake *FakeIngressStore) UpdateIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) {
+	fake.updateIngressMutex.Lock()
+	defer fake.updateIngressMutex.Unlock()
+	fake.UpdateIngressStub = stub
+}
+
+func (fake *FakeIngressStore) UpdateIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) {
+	fake.updateIngressMutex.RLock()
+	defer fake.updateIngressMutex.RUnlock()
+	argsForCall := fake.updateIngressArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeIngressStore) UpdateIngressReturns(result1 error) {
+	fake.updateIngressMutex.Lock()
+	defer fake.updateIngressMutex.Unlock()
+	fake.UpdateIngressStub = nil
+	fake.updateIngressReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeIngressStore) UpdateIngressReturnsOnCall(i int, result1 error) {
+	fake.updateIngressMutex.Lock()
+	defer fake.updateIngressMutex.Unlock()
+	fake.UpdateIngressStub = nil
+	if fake.updateIngressReturnsOnCall == nil {
+		fake.updateIngressReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.updateIngressReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeIngressStore) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	fake.deleteIngressMutex.RLock()
+	defer fake.deleteIngressMutex.RUnlock()
+	fake.listIngressMutex.RLock()
+	defer fake.listIngressMutex.RUnlock()
+	fake.loadIngressMutex.RLock()
+	defer fake.loadIngressMutex.RUnlock()
+	fake.loadIngressFromStreamKeyMutex.RLock()
+	defer fake.loadIngressFromStreamKeyMutex.RUnlock()
+	fake.storeIngressMutex.RLock()
+	defer fake.storeIngressMutex.RUnlock()
+	fake.updateIngressMutex.RLock()
+	defer fake.updateIngressMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeIngressStore) recordInvocation(key string, args []interface{}) {
+	fake.invocationsMutex.Lock()
+	defer fake.invocationsMutex.Unlock()
+	if fake.invocations == nil {
+		fake.invocations = map[string][][]interface{}{}
+	}
+	if fake.invocations[key] == nil {
+		fake.invocations[key] = [][]interface{}{}
+	}
+	fake.invocations[key] = append(fake.invocations[key], args)
+}
+
+var _ service.IngressStore = new(FakeIngressStore)
@@ -11,30 +11,6 @@ import (
 )

 type FakeObjectStore struct {
-	DeleteEgressStub        func(context.Context, *livekit.EgressInfo) error
-	deleteEgressMutex       sync.RWMutex
-	deleteEgressArgsForCall []struct {
-		arg1 context.Context
-		arg2 *livekit.EgressInfo
-	}
-	deleteEgressReturns struct {
-		result1 error
-	}
-	deleteEgressReturnsOnCall map[int]struct {
-		result1 error
-	}
-	DeleteIngressStub        func(context.Context, *livekit.IngressInfo) error
-	deleteIngressMutex       sync.RWMutex
-	deleteIngressArgsForCall []struct {
-		arg1 context.Context
-		arg2 *livekit.IngressInfo
-	}
-	deleteIngressReturns struct {
-		result1 error
-	}
-	deleteIngressReturnsOnCall map[int]struct {
-		result1 error
-	}
 	DeleteParticipantStub        func(context.Context, livekit.RoomName, livekit.ParticipantIdentity) error
 	deleteParticipantMutex       sync.RWMutex
 	deleteParticipantArgsForCall []struct {
@@ -60,34 +36,6 @@ type FakeObjectStore struct {
 	deleteRoomReturnsOnCall map[int]struct {
 		result1 error
 	}
-	ListEgressStub        func(context.Context, livekit.RoomID) ([]*livekit.EgressInfo, error)
-	listEgressMutex       sync.RWMutex
-	listEgressArgsForCall []struct {
-		arg1 context.Context
-		arg2 livekit.RoomID
-	}
-	listEgressReturns struct {
-		result1 []*livekit.EgressInfo
-		result2 error
-	}
-	listEgressReturnsOnCall map[int]struct {
-		result1 []*livekit.EgressInfo
-		result2 error
-	}
-	ListIngressStub        func(context.Context, livekit.RoomName) ([]*livekit.IngressInfo, error)
-	listIngressMutex       sync.RWMutex
-	listIngressArgsForCall []struct {
-		arg1 context.Context
-		arg2 livekit.RoomName
-	}
-	listIngressReturns struct {
-		result1 []*livekit.IngressInfo
-		result2 error
-	}
-	listIngressReturnsOnCall map[int]struct {
-		result1 []*livekit.IngressInfo
-		result2 error
-	}
 	ListParticipantsStub        func(context.Context, livekit.RoomName) ([]*livekit.ParticipantInfo, error)
 	listParticipantsMutex       sync.RWMutex
 	listParticipantsArgsForCall []struct {
@@ -116,48 +64,6 @@ type FakeObjectStore struct {
 		result1 []*livekit.Room
 		result2 error
 	}
-	LoadEgressStub        func(context.Context, string) (*livekit.EgressInfo, error)
-	loadEgressMutex       sync.RWMutex
-	loadEgressArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-	}
-	loadEgressReturns struct {
-		result1 *livekit.EgressInfo
-		result2 error
-	}
-	loadEgressReturnsOnCall map[int]struct {
-		result1 *livekit.EgressInfo
-		result2 error
-	}
-	LoadIngressStub        func(context.Context, string) (*livekit.IngressInfo, error)
-	loadIngressMutex       sync.RWMutex
-	loadIngressArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-	}
-	loadIngressReturns struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}
-	loadIngressReturnsOnCall map[int]struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}
-	LoadIngressFromStreamKeyStub        func(context.Context, string) (*livekit.IngressInfo, error)
-	loadIngressFromStreamKeyMutex       sync.RWMutex
-	loadIngressFromStreamKeyArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-	}
-	loadIngressFromStreamKeyReturns struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}
-	loadIngressFromStreamKeyReturnsOnCall map[int]struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}
 	LoadParticipantStub        func(context.Context, livekit.RoomName, livekit.ParticipantIdentity) (*livekit.ParticipantInfo, error)
 	loadParticipantMutex       sync.RWMutex
 	loadParticipantArgsForCall []struct {
@@ -202,30 +108,6 @@ type FakeObjectStore struct {
 		result1 string
 		result2 error
 	}
-	StoreEgressStub        func(context.Context, *livekit.EgressInfo) error
-	storeEgressMutex       sync.RWMutex
-	storeEgressArgsForCall []struct {
-		arg1 context.Context
-		arg2 *livekit.EgressInfo
-	}
-	storeEgressReturns struct {
-		result1 error
-	}
-	storeEgressReturnsOnCall map[int]struct {
-		result1 error
-	}
-	StoreIngressStub        func(context.Context, *livekit.IngressInfo) error
-	storeIngressMutex       sync.RWMutex
-	storeIngressArgsForCall []struct {
-		arg1 context.Context
-		arg2 *livekit.IngressInfo
-	}
-	storeIngressReturns struct {
-		result1 error
-	}
-	storeIngressReturnsOnCall map[int]struct {
-		result1 error
-	}
 	StoreParticipantStub        func(context.Context, livekit.RoomName, *livekit.ParticipantInfo) error
 	storeParticipantMutex       sync.RWMutex
 	storeParticipantArgsForCall []struct {
@@ -264,158 +146,10 @@ type FakeObjectStore struct {
 	unlockRoomReturnsOnCall map[int]struct {
 		result1 error
 	}
-	UpdateEgressStub        func(context.Context, *livekit.EgressInfo) error
-	updateEgressMutex       sync.RWMutex
-	updateEgressArgsForCall []struct {
-		arg1 context.Context
-		arg2 *livekit.EgressInfo
-	}
-	updateEgressReturns struct {
-		result1 error
-	}
-	updateEgressReturnsOnCall map[int]struct {
-		result1 error
-	}
-	UpdateIngressStub        func(context.Context, *livekit.IngressInfo) error
-	updateIngressMutex       sync.RWMutex
-	updateIngressArgsForCall []struct {
-		arg1 context.Context
-		arg2 *livekit.IngressInfo
-	}
-	updateIngressReturns struct {
-		result1 error
-	}
-	updateIngressReturnsOnCall map[int]struct {
-		result1 error
-	}
 	invocations      map[string][][]interface{}
 	invocationsMutex sync.RWMutex
 }

-func (fake *FakeObjectStore) DeleteEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error {
-	fake.deleteEgressMutex.Lock()
-	ret, specificReturn := fake.deleteEgressReturnsOnCall[len(fake.deleteEgressArgsForCall)]
-	fake.deleteEgressArgsForCall = append(fake.deleteEgressArgsForCall, struct {
-		arg1 context.Context
-		arg2 *livekit.EgressInfo
-	}{arg1, arg2})
-	stub := fake.DeleteEgressStub
-	fakeReturns := fake.deleteEgressReturns
-	fake.recordInvocation("DeleteEgress", []interface{}{arg1, arg2})
-	fake.deleteEgressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *FakeObjectStore) DeleteEgressCallCount() int {
-	fake.deleteEgressMutex.RLock()
-	defer fake.deleteEgressMutex.RUnlock()
-	return len(fake.deleteEgressArgsForCall)
-}
-
-func (fake *FakeObjectStore) DeleteEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) {
-	fake.deleteEgressMutex.Lock()
-	defer fake.deleteEgressMutex.Unlock()
-	fake.DeleteEgressStub = stub
-}
-
-func (fake *FakeObjectStore) DeleteEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) {
-	fake.deleteEgressMutex.RLock()
-	defer fake.deleteEgressMutex.RUnlock()
-	argsForCall := fake.deleteEgressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeObjectStore) DeleteEgressReturns(result1 error) {
-	fake.deleteEgressMutex.Lock()
-	defer fake.deleteEgressMutex.Unlock()
-	fake.DeleteEgressStub = nil
-	fake.deleteEgressReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeObjectStore) DeleteEgressReturnsOnCall(i int, result1 error) {
-	fake.deleteEgressMutex.Lock()
-	defer fake.deleteEgressMutex.Unlock()
-	fake.DeleteEgressStub = nil
-	if fake.deleteEgressReturnsOnCall == nil {
-		fake.deleteEgressReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.deleteEgressReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeObjectStore) DeleteIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error {
-	fake.deleteIngressMutex.Lock()
-	ret, specificReturn := fake.deleteIngressReturnsOnCall[len(fake.deleteIngressArgsForCall)]
-	fake.deleteIngressArgsForCall = append(fake.deleteIngressArgsForCall, struct {
-		arg1 context.Context
-		arg2 *livekit.IngressInfo
-	}{arg1, arg2})
-	stub := fake.DeleteIngressStub
-	fakeReturns := fake.deleteIngressReturns
-	fake.recordInvocation("DeleteIngress", []interface{}{arg1, arg2})
-	fake.deleteIngressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *FakeObjectStore) DeleteIngressCallCount() int {
-	fake.deleteIngressMutex.RLock()
-	defer fake.deleteIngressMutex.RUnlock()
-	return len(fake.deleteIngressArgsForCall)
-}
-
-func (fake *FakeObjectStore) DeleteIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) {
-	fake.deleteIngressMutex.Lock()
-	defer fake.deleteIngressMutex.Unlock()
-	fake.DeleteIngressStub = stub
-}
-
-func (fake *FakeObjectStore) DeleteIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) {
-	fake.deleteIngressMutex.RLock()
-	defer fake.deleteIngressMutex.RUnlock()
-	argsForCall := fake.deleteIngressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeObjectStore) DeleteIngressReturns(result1 error) {
-	fake.deleteIngressMutex.Lock()
-	defer fake.deleteIngressMutex.Unlock()
-	fake.DeleteIngressStub = nil
-	fake.deleteIngressReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeObjectStore) DeleteIngressReturnsOnCall(i int, result1 error) {
-	fake.deleteIngressMutex.Lock()
-	defer fake.deleteIngressMutex.Unlock()
-	fake.DeleteIngressStub = nil
-	if fake.deleteIngressReturnsOnCall == nil {
-		fake.deleteIngressReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.deleteIngressReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
 func (fake *FakeObjectStore) DeleteParticipant(arg1 context.Context, arg2 livekit.RoomName, arg3 livekit.ParticipantIdentity) error {
 	fake.deleteParticipantMutex.Lock()
 	ret, specificReturn := fake.deleteParticipantReturnsOnCall[len(fake.deleteParticipantArgsForCall)]
@@ -541,136 +275,6 @@ func (fake *FakeObjectStore) DeleteRoomReturnsOnCall(i int, result1 error) {
 	}{result1}
 }

-func (fake *FakeObjectStore) ListEgress(arg1 context.Context, arg2 livekit.RoomID) ([]*livekit.EgressInfo, error) {
-	fake.listEgressMutex.Lock()
-	ret, specificReturn := fake.listEgressReturnsOnCall[len(fake.listEgressArgsForCall)]
-	fake.listEgressArgsForCall = append(fake.listEgressArgsForCall, struct {
-		arg1 context.Context
-		arg2 livekit.RoomID
-	}{arg1, arg2})
-	stub := fake.ListEgressStub
-	fakeReturns := fake.listEgressReturns
-	fake.recordInvocation("ListEgress", []interface{}{arg1, arg2})
-	fake.listEgressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeObjectStore) ListEgressCallCount() int {
-	fake.listEgressMutex.RLock()
-	defer fake.listEgressMutex.RUnlock()
-	return len(fake.listEgressArgsForCall)
-}
-
-func (fake *FakeObjectStore) ListEgressCalls(stub func(context.Context, livekit.RoomID) ([]*livekit.EgressInfo, error)) {
-	fake.listEgressMutex.Lock()
-	defer fake.listEgressMutex.Unlock()
-	fake.ListEgressStub = stub
-}
-
-func (fake *FakeObjectStore) ListEgressArgsForCall(i int) (context.Context, livekit.RoomID) {
-	fake.listEgressMutex.RLock()
-	defer fake.listEgressMutex.RUnlock()
-	argsForCall := fake.listEgressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeObjectStore) ListEgressReturns(result1 []*livekit.EgressInfo, result2 error) {
-	fake.listEgressMutex.Lock()
-	defer fake.listEgressMutex.Unlock()
-	fake.ListEgressStub = nil
-	fake.listEgressReturns = struct {
-		result1 []*livekit.EgressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeObjectStore) ListEgressReturnsOnCall(i int, result1 []*livekit.EgressInfo, result2 error) {
-	fake.listEgressMutex.Lock()
-	defer fake.listEgressMutex.Unlock()
-	fake.ListEgressStub = nil
-	if fake.listEgressReturnsOnCall == nil {
-		fake.listEgressReturnsOnCall = make(map[int]struct {
-			result1 []*livekit.EgressInfo
-			result2 error
-		})
-	}
-	fake.listEgressReturnsOnCall[i] = struct {
-		result1 []*livekit.EgressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeObjectStore) ListIngress(arg1 context.Context, arg2 livekit.RoomName) ([]*livekit.IngressInfo, error) {
-	fake.listIngressMutex.Lock()
-	ret, specificReturn := fake.listIngressReturnsOnCall[len(fake.listIngressArgsForCall)]
-	fake.listIngressArgsForCall = append(fake.listIngressArgsForCall, struct {
-		arg1 context.Context
-		arg2 livekit.RoomName
-	}{arg1, arg2})
-	stub := fake.ListIngressStub
-	fakeReturns := fake.listIngressReturns
-	fake.recordInvocation("ListIngress", []interface{}{arg1, arg2})
-	fake.listIngressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeObjectStore) ListIngressCallCount() int {
-	fake.listIngressMutex.RLock()
-	defer fake.listIngressMutex.RUnlock()
-	return len(fake.listIngressArgsForCall)
-}
-
-func (fake *FakeObjectStore) ListIngressCalls(stub func(context.Context, livekit.RoomName) ([]*livekit.IngressInfo, error)) {
-	fake.listIngressMutex.Lock()
-	defer fake.listIngressMutex.Unlock()
-	fake.ListIngressStub = stub
-}
-
-func (fake *FakeObjectStore) ListIngressArgsForCall(i int) (context.Context, livekit.RoomName) {
-	fake.listIngressMutex.RLock()
-	defer fake.listIngressMutex.RUnlock()
-	argsForCall := fake.listIngressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeObjectStore) ListIngressReturns(result1 []*livekit.IngressInfo, result2 error) {
-	fake.listIngressMutex.Lock()
-	defer fake.listIngressMutex.Unlock()
-	fake.ListIngressStub = nil
-	fake.listIngressReturns = struct {
-		result1 []*livekit.IngressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeObjectStore) ListIngressReturnsOnCall(i int, result1 []*livekit.IngressInfo, result2 error) {
-	fake.listIngressMutex.Lock()
-	defer fake.listIngressMutex.Unlock()
-	fake.ListIngressStub = nil
-	if fake.listIngressReturnsOnCall == nil {
-		fake.listIngressReturnsOnCall = make(map[int]struct {
-			result1 []*livekit.IngressInfo
-			result2 error
-		})
-	}
-	fake.listIngressReturnsOnCall[i] = struct {
-		result1 []*livekit.IngressInfo
-		result2 error
-	}{result1, result2}
-}
-
 func (fake *FakeObjectStore) ListParticipants(arg1 context.Context, arg2 livekit.RoomName) ([]*livekit.ParticipantInfo, error) {
 	fake.listParticipantsMutex.Lock()
 	ret, specificReturn := fake.listParticipantsReturnsOnCall[len(fake.listParticipantsArgsForCall)]
@@ -806,201 +410,6 @@ func (fake *FakeObjectStore) ListRoomsReturnsOnCall(i int, result1 []*livekit.Ro
 	}{result1, result2}
 }

-func (fake *FakeObjectStore) LoadEgress(arg1 context.Context, arg2 string) (*livekit.EgressInfo, error) {
-	fake.loadEgressMutex.Lock()
-	ret, specificReturn := fake.loadEgressReturnsOnCall[len(fake.loadEgressArgsForCall)]
-	fake.loadEgressArgsForCall = append(fake.loadEgressArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-	}{arg1, arg2})
-	stub := fake.LoadEgressStub
-	fakeReturns := fake.loadEgressReturns
-	fake.recordInvocation("LoadEgress", []interface{}{arg1, arg2})
-	fake.loadEgressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeObjectStore) LoadEgressCallCount() int {
-	fake.loadEgressMutex.RLock()
-	defer fake.loadEgressMutex.RUnlock()
-	return len(fake.loadEgressArgsForCall)
-}
-
-func (fake *FakeObjectStore) LoadEgressCalls(stub func(context.Context, string) (*livekit.EgressInfo, error)) {
-	fake.loadEgressMutex.Lock()
-	defer fake.loadEgressMutex.Unlock()
-	fake.LoadEgressStub = stub
-}
-
-func (fake *FakeObjectStore) LoadEgressArgsForCall(i int) (context.Context, string) {
-	fake.loadEgressMutex.RLock()
-	defer fake.loadEgressMutex.RUnlock()
-	argsForCall := fake.loadEgressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeObjectStore) LoadEgressReturns(result1 *livekit.EgressInfo, result2 error) {
-	fake.loadEgressMutex.Lock()
-	defer fake.loadEgressMutex.Unlock()
-	fake.LoadEgressStub = nil
-	fake.loadEgressReturns = struct {
-		result1 *livekit.EgressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeObjectStore) LoadEgressReturnsOnCall(i int, result1 *livekit.EgressInfo, result2 error) {
-	fake.loadEgressMutex.Lock()
-	defer fake.loadEgressMutex.Unlock()
-	fake.LoadEgressStub = nil
-	if fake.loadEgressReturnsOnCall == nil {
-		fake.loadEgressReturnsOnCall = make(map[int]struct {
-			result1 *livekit.EgressInfo
-			result2 error
-		})
-	}
-	fake.loadEgressReturnsOnCall[i] = struct {
-		result1 *livekit.EgressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeObjectStore) LoadIngress(arg1 context.Context, arg2 string) (*livekit.IngressInfo, error) {
-	fake.loadIngressMutex.Lock()
-	ret, specificReturn := fake.loadIngressReturnsOnCall[len(fake.loadIngressArgsForCall)]
-	fake.loadIngressArgsForCall = append(fake.loadIngressArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-	}{arg1, arg2})
-	stub := fake.LoadIngressStub
-	fakeReturns := fake.loadIngressReturns
-	fake.recordInvocation("LoadIngress", []interface{}{arg1, arg2})
-	fake.loadIngressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeObjectStore) LoadIngressCallCount() int {
-	fake.loadIngressMutex.RLock()
-	defer fake.loadIngressMutex.RUnlock()
-	return len(fake.loadIngressArgsForCall)
-}
-
-func (fake *FakeObjectStore) LoadIngressCalls(stub func(context.Context, string) (*livekit.IngressInfo, error)) {
-	fake.loadIngressMutex.Lock()
-	defer fake.loadIngressMutex.Unlock()
-	fake.LoadIngressStub = stub
-}
-
-func (fake *FakeObjectStore) LoadIngressArgsForCall(i int) (context.Context, string) {
-	fake.loadIngressMutex.RLock()
-	defer fake.loadIngressMutex.RUnlock()
-	argsForCall := fake.loadIngressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeObjectStore) LoadIngressReturns(result1 *livekit.IngressInfo, result2 error) {
-	fake.loadIngressMutex.Lock()
-	defer fake.loadIngressMutex.Unlock()
-	fake.LoadIngressStub = nil
-	fake.loadIngressReturns = struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeObjectStore) LoadIngressReturnsOnCall(i int, result1 *livekit.IngressInfo, result2 error) {
-	fake.loadIngressMutex.Lock()
-	defer fake.loadIngressMutex.Unlock()
-	fake.LoadIngressStub = nil
-	if fake.loadIngressReturnsOnCall == nil {
-		fake.loadIngressReturnsOnCall = make(map[int]struct {
-			result1 *livekit.IngressInfo
-			result2 error
-		})
-	}
-	fake.loadIngressReturnsOnCall[i] = struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeObjectStore) LoadIngressFromStreamKey(arg1 context.Context, arg2 string) (*livekit.IngressInfo, error) {
-	fake.loadIngressFromStreamKeyMutex.Lock()
-	ret, specificReturn := fake.loadIngressFromStreamKeyReturnsOnCall[len(fake.loadIngressFromStreamKeyArgsForCall)]
-	fake.loadIngressFromStreamKeyArgsForCall = append(fake.loadIngressFromStreamKeyArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-	}{arg1, arg2})
-	stub := fake.LoadIngressFromStreamKeyStub
-	fakeReturns := fake.loadIngressFromStreamKeyReturns
-	fake.recordInvocation("LoadIngressFromStreamKey", []interface{}{arg1, arg2})
-	fake.loadIngressFromStreamKeyMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeObjectStore) LoadIngressFromStreamKeyCallCount() int {
-	fake.loadIngressFromStreamKeyMutex.RLock()
-	defer fake.loadIngressFromStreamKeyMutex.RUnlock()
-	return len(fake.loadIngressFromStreamKeyArgsForCall)
-}
-
-func (fake *FakeObjectStore) LoadIngressFromStreamKeyCalls(stub func(context.Context, string) (*livekit.IngressInfo, error)) {
-	fake.loadIngressFromStreamKeyMutex.Lock()
-	defer fake.loadIngressFromStreamKeyMutex.Unlock()
-	fake.LoadIngressFromStreamKeyStub = stub
-}
-
-func (fake *FakeObjectStore) LoadIngressFromStreamKeyArgsForCall(i int) (context.Context, string) {
-	fake.loadIngressFromStreamKeyMutex.RLock()
-	defer fake.loadIngressFromStreamKeyMutex.RUnlock()
-	argsForCall := fake.loadIngressFromStreamKeyArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeObjectStore) LoadIngressFromStreamKeyReturns(result1 *livekit.IngressInfo, result2 error) {
-	fake.loadIngressFromStreamKeyMutex.Lock()
-	defer fake.loadIngressFromStreamKeyMutex.Unlock()
-	fake.LoadIngressFromStreamKeyStub = nil
-	fake.loadIngressFromStreamKeyReturns = struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeObjectStore) LoadIngressFromStreamKeyReturnsOnCall(i int, result1 *livekit.IngressInfo, result2 error) {
-	fake.loadIngressFromStreamKeyMutex.Lock()
-	defer fake.loadIngressFromStreamKeyMutex.Unlock()
-	fake.LoadIngressFromStreamKeyStub = nil
-	if fake.loadIngressFromStreamKeyReturnsOnCall == nil {
-		fake.loadIngressFromStreamKeyReturnsOnCall = make(map[int]struct {
-			result1 *livekit.IngressInfo
-			result2 error
-		})
-	}
-	fake.loadIngressFromStreamKeyReturnsOnCall[i] = struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}{result1, result2}
-}
-
 func (fake *FakeObjectStore) LoadParticipant(arg1 context.Context, arg2 livekit.RoomName, arg3 livekit.ParticipantIdentity) (*livekit.ParticipantInfo, error) {
 	fake.loadParticipantMutex.Lock()
 	ret, specificReturn := fake.loadParticipantReturnsOnCall[len(fake.loadParticipantArgsForCall)]
@@ -1198,130 +607,6 @@ func (fake *FakeObjectStore) LockRoomReturnsOnCall(i int, result1 string, result
 	}{result1, result2}
 }

-func (fake *FakeObjectStore) StoreEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error {
-	fake.storeEgressMutex.Lock()
-	ret, specificReturn := fake.storeEgressReturnsOnCall[len(fake.storeEgressArgsForCall)]
-	fake.storeEgressArgsForCall = append(fake.storeEgressArgsForCall, struct {
-		arg1 context.Context
-		arg2 *livekit.EgressInfo
-	}{arg1, arg2})
-	stub := fake.StoreEgressStub
-	fakeReturns := fake.storeEgressReturns
-	fake.recordInvocation("StoreEgress", []interface{}{arg1, arg2})
-	fake.storeEgressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *FakeObjectStore) StoreEgressCallCount() int {
-	fake.storeEgressMutex.RLock()
-	defer fake.storeEgressMutex.RUnlock()
-	return len(fake.storeEgressArgsForCall)
-}
-
-func (fake *FakeObjectStore) StoreEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) {
-	fake.storeEgressMutex.Lock()
-	defer fake.storeEgressMutex.Unlock()
-	fake.StoreEgressStub = stub
-}
-
-func (fake *FakeObjectStore) StoreEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) {
-	fake.storeEgressMutex.RLock()
-	defer fake.storeEgressMutex.RUnlock()
-	argsForCall := fake.storeEgressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeObjectStore) StoreEgressReturns(result1 error) {
-	fake.storeEgressMutex.Lock()
-	defer fake.storeEgressMutex.Unlock()
-	fake.StoreEgressStub = nil
-	fake.storeEgressReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeObjectStore) StoreEgressReturnsOnCall(i int, result1 error) {
-	fake.storeEgressMutex.Lock()
-	defer fake.storeEgressMutex.Unlock()
-	fake.StoreEgressStub = nil
-	if fake.storeEgressReturnsOnCall == nil {
-		fake.storeEgressReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.storeEgressReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeObjectStore) StoreIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error {
-	fake.storeIngressMutex.Lock()
-	ret, specificReturn := fake.storeIngressReturnsOnCall[len(fake.storeIngressArgsForCall)]
-	fake.storeIngressArgsForCall = append(fake.storeIngressArgsForCall, struct {
-		arg1 context.Context
-		arg2 *livekit.IngressInfo
-	}{arg1, arg2})
-	stub := fake.StoreIngressStub
-	fakeReturns := fake.storeIngressReturns
-	fake.recordInvocation("StoreIngress", []interface{}{arg1, arg2})
-	fake.storeIngressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *FakeObjectStore) StoreIngressCallCount() int {
-	fake.storeIngressMutex.RLock()
-	defer fake.storeIngressMutex.RUnlock()
-	return len(fake.storeIngressArgsForCall)
-}
-
-func (fake *FakeObjectStore) StoreIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) {
-	fake.storeIngressMutex.Lock()
-	defer fake.storeIngressMutex.Unlock()
-	fake.StoreIngressStub = stub
-}
-
-func (fake *FakeObjectStore) StoreIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) {
-	fake.storeIngressMutex.RLock()
-	defer fake.storeIngressMutex.RUnlock()
-	argsForCall := fake.storeIngressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeObjectStore) StoreIngressReturns(result1 error) {
-	fake.storeIngressMutex.Lock()
-	defer fake.storeIngressMutex.Unlock()
-	fake.StoreIngressStub = nil
-	fake.storeIngressReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeObjectStore) StoreIngressReturnsOnCall(i int, result1 error) {
-	fake.storeIngressMutex.Lock()
-	defer fake.storeIngressMutex.Unlock()
-	fake.StoreIngressStub = nil
-	if fake.storeIngressReturnsOnCall == nil {
-		fake.storeIngressReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.storeIngressReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
 func (fake *FakeObjectStore) StoreParticipant(arg1 context.Context, arg2 livekit.RoomName, arg3 *livekit.ParticipantInfo) error {
 	fake.storeParticipantMutex.Lock()
 	ret, specificReturn := fake.storeParticipantReturnsOnCall[len(fake.storeParticipantArgsForCall)]
@@ -1510,175 +795,29 @@ func (fake *FakeObjectStore) UnlockRoomReturnsOnCall(i int, result1 error) {
 	}{result1}
 }

-func (fake *FakeObjectStore) UpdateEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error {
-	fake.updateEgressMutex.Lock()
-	ret, specificReturn := fake.updateEgressReturnsOnCall[len(fake.updateEgressArgsForCall)]
-	fake.updateEgressArgsForCall = append(fake.updateEgressArgsForCall, struct {
-		arg1 context.Context
-		arg2 *livekit.EgressInfo
-	}{arg1, arg2})
-	stub := fake.UpdateEgressStub
-	fakeReturns := fake.updateEgressReturns
-	fake.recordInvocation("UpdateEgress", []interface{}{arg1, arg2})
-	fake.updateEgressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *FakeObjectStore) UpdateEgressCallCount() int {
-	fake.updateEgressMutex.RLock()
-	defer fake.updateEgressMutex.RUnlock()
-	return len(fake.updateEgressArgsForCall)
-}
-
-func (fake *FakeObjectStore) UpdateEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) {
-	fake.updateEgressMutex.Lock()
-	defer fake.updateEgressMutex.Unlock()
-	fake.UpdateEgressStub = stub
-}
-
-func (fake *FakeObjectStore) UpdateEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) {
-	fake.updateEgressMutex.RLock()
-	defer fake.updateEgressMutex.RUnlock()
-	argsForCall := fake.updateEgressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeObjectStore) UpdateEgressReturns(result1 error) {
-	fake.updateEgressMutex.Lock()
-	defer fake.updateEgressMutex.Unlock()
-	fake.UpdateEgressStub = nil
-	fake.updateEgressReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeObjectStore) UpdateEgressReturnsOnCall(i int, result1 error) {
-	fake.updateEgressMutex.Lock()
-	defer fake.updateEgressMutex.Unlock()
-	fake.UpdateEgressStub = nil
-	if fake.updateEgressReturnsOnCall == nil {
-		fake.updateEgressReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.updateEgressReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeObjectStore) UpdateIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error {
-	fake.updateIngressMutex.Lock()
-	ret, specificReturn := fake.updateIngressReturnsOnCall[len(fake.updateIngressArgsForCall)]
-	fake.updateIngressArgsForCall = append(fake.updateIngressArgsForCall, struct {
-		arg1 context.Context
-		arg2 *livekit.IngressInfo
-	}{arg1, arg2})
-	stub := fake.UpdateIngressStub
-	fakeReturns := fake.updateIngressReturns
-	fake.recordInvocation("UpdateIngress", []interface{}{arg1, arg2})
-	fake.updateIngressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *FakeObjectStore) UpdateIngressCallCount() int {
-	fake.updateIngressMutex.RLock()
-	defer fake.updateIngressMutex.RUnlock()
-	return len(fake.updateIngressArgsForCall)
-}
-
-func (fake *FakeObjectStore) UpdateIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) {
-	fake.updateIngressMutex.Lock()
-	defer fake.updateIngressMutex.Unlock()
-	fake.UpdateIngressStub = stub
-}
-
-func (fake *FakeObjectStore) UpdateIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) {
-	fake.updateIngressMutex.RLock()
-	defer fake.updateIngressMutex.RUnlock()
-	argsForCall := fake.updateIngressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeObjectStore) UpdateIngressReturns(result1 error) {
-	fake.updateIngressMutex.Lock()
-	defer fake.updateIngressMutex.Unlock()
-	fake.UpdateIngressStub = nil
-	fake.updateIngressReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeObjectStore) UpdateIngressReturnsOnCall(i int, result1 error) {
-	fake.updateIngressMutex.Lock()
-	defer fake.updateIngressMutex.Unlock()
-	fake.UpdateIngressStub = nil
-	if fake.updateIngressReturnsOnCall == nil {
-		fake.updateIngressReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.updateIngressReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
 func (fake *FakeObjectStore) Invocations() map[string][][]interface{} {
 	fake.invocationsMutex.RLock()
 	defer fake.invocationsMutex.RUnlock()
-	fake.deleteEgressMutex.RLock()
-	defer fake.deleteEgressMutex.RUnlock()
-	fake.deleteIngressMutex.RLock()
-	defer fake.deleteIngressMutex.RUnlock()
 	fake.deleteParticipantMutex.RLock()
 	defer fake.deleteParticipantMutex.RUnlock()
 	fake.deleteRoomMutex.RLock()
 	defer fake.deleteRoomMutex.RUnlock()
-	fake.listEgressMutex.RLock()
-	defer fake.listEgressMutex.RUnlock()
-	fake.listIngressMutex.RLock()
-	defer fake.listIngressMutex.RUnlock()
 	fake.listParticipantsMutex.RLock()
 	defer fake.listParticipantsMutex.RUnlock()
 	fake.listRoomsMutex.RLock()
 	defer fake.listRoomsMutex.RUnlock()
-	fake.loadEgressMutex.RLock()
-	defer fake.loadEgressMutex.RUnlock()
-	fake.loadIngressMutex.RLock()
-	defer fake.loadIngressMutex.RUnlock()
-	fake.loadIngressFromStreamKeyMutex.RLock()
-	defer fake.loadIngressFromStreamKeyMutex.RUnlock()
 	fake.loadParticipantMutex.RLock()
 	defer fake.loadParticipantMutex.RUnlock()
 	fake.loadRoomMutex.RLock()
 	defer fake.loadRoomMutex.RUnlock()
 	fake.lockRoomMutex.RLock()
 	defer fake.lockRoomMutex.RUnlock()
-	fake.storeEgressMutex.RLock()
-	defer fake.storeEgressMutex.RUnlock()
-	fake.storeIngressMutex.RLock()
-	defer fake.storeIngressMutex.RUnlock()
 	fake.storeParticipantMutex.RLock()
 	defer fake.storeParticipantMutex.RUnlock()
 	fake.storeRoomMutex.RLock()
 	defer fake.storeRoomMutex.RUnlock()
 	fake.unlockRoomMutex.RLock()
 	defer fake.unlockRoomMutex.RUnlock()
-	fake.updateEgressMutex.RLock()
-	defer fake.updateEgressMutex.RUnlock()
-	fake.updateIngressMutex.RLock()
-	defer fake.updateIngressMutex.RUnlock()
 	copiedInvocations := map[string][][]interface{}{}
 	for key, value := range fake.invocations {
 		copiedInvocations[key] = value
@@ -10,58 +10,6 @@ import (
 )

 type FakeServiceStore struct {
-	DeleteEgressStub        func(context.Context, *livekit.EgressInfo) error
-	deleteEgressMutex       sync.RWMutex
-	deleteEgressArgsForCall []struct {
-		arg1 context.Context
-		arg2 *livekit.EgressInfo
-	}
-	deleteEgressReturns struct {
-		result1 error
-	}
-	deleteEgressReturnsOnCall map[int]struct {
-		result1 error
-	}
-	DeleteIngressStub        func(context.Context, *livekit.IngressInfo) error
-	deleteIngressMutex       sync.RWMutex
-	deleteIngressArgsForCall []struct {
-		arg1 context.Context
-		arg2 *livekit.IngressInfo
-	}
-	deleteIngressReturns struct {
-		result1 error
-	}
-	deleteIngressReturnsOnCall map[int]struct {
-		result1 error
-	}
-	ListEgressStub        func(context.Context, livekit.RoomID) ([]*livekit.EgressInfo, error)
-	listEgressMutex       sync.RWMutex
-	listEgressArgsForCall []struct {
-		arg1 context.Context
-		arg2 livekit.RoomID
-	}
-	listEgressReturns struct {
-		result1 []*livekit.EgressInfo
-		result2 error
-	}
-	listEgressReturnsOnCall map[int]struct {
-		result1 []*livekit.EgressInfo
-		result2 error
-	}
-	ListIngressStub        func(context.Context, livekit.RoomName) ([]*livekit.IngressInfo, error)
-	listIngressMutex       sync.RWMutex
-	listIngressArgsForCall []struct {
-		arg1 context.Context
-		arg2 livekit.RoomName
-	}
-	listIngressReturns struct {
-		result1 []*livekit.IngressInfo
-		result2 error
-	}
-	listIngressReturnsOnCall map[int]struct {
-		result1 []*livekit.IngressInfo
-		result2 error
-	}
 	ListParticipantsStub        func(context.Context, livekit.RoomName) ([]*livekit.ParticipantInfo, error)
 	listParticipantsMutex       sync.RWMutex
 	listParticipantsArgsForCall []struct {
@@ -90,48 +38,6 @@ type FakeServiceStore struct {
 		result1 []*livekit.Room
 		result2 error
 	}
-	LoadEgressStub        func(context.Context, string) (*livekit.EgressInfo, error)
-	loadEgressMutex       sync.RWMutex
-	loadEgressArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-	}
-	loadEgressReturns struct {
-		result1 *livekit.EgressInfo
-		result2 error
-	}
-	loadEgressReturnsOnCall map[int]struct {
-		result1 *livekit.EgressInfo
-		result2 error
-	}
-	LoadIngressStub        func(context.Context, string) (*livekit.IngressInfo, error)
-	loadIngressMutex       sync.RWMutex
-	loadIngressArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-	}
-	loadIngressReturns struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}
-	loadIngressReturnsOnCall map[int]struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}
-	LoadIngressFromStreamKeyStub        func(context.Context, string) (*livekit.IngressInfo, error)
-	loadIngressFromStreamKeyMutex       sync.RWMutex
-	loadIngressFromStreamKeyArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-	}
-	loadIngressFromStreamKeyReturns struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}
-	loadIngressFromStreamKeyReturnsOnCall map[int]struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}
 	LoadParticipantStub        func(context.Context, livekit.RoomName, livekit.ParticipantIdentity) (*livekit.ParticipantInfo, error)
 	loadParticipantMutex       sync.RWMutex
 	loadParticipantArgsForCall []struct {
@@ -161,312 +67,10 @@ type FakeServiceStore struct {
 		result1 *livekit.Room
 		result2 error
 	}
-	StoreEgressStub        func(context.Context, *livekit.EgressInfo) error
-	storeEgressMutex       sync.RWMutex
-	storeEgressArgsForCall []struct {
-		arg1 context.Context
-		arg2 *livekit.EgressInfo
-	}
-	storeEgressReturns struct {
-		result1 error
-	}
-	storeEgressReturnsOnCall map[int]struct {
-		result1 error
-	}
-	StoreIngressStub        func(context.Context, *livekit.IngressInfo) error
-	storeIngressMutex       sync.RWMutex
-	storeIngressArgsForCall []struct {
-		arg1 context.Context
-		arg2 *livekit.IngressInfo
-	}
-	storeIngressReturns struct {
-		result1 error
-	}
-	storeIngressReturnsOnCall map[int]struct {
-		result1 error
-	}
-	UpdateEgressStub        func(context.Context, *livekit.EgressInfo) error
-	updateEgressMutex       sync.RWMutex
-	updateEgressArgsForCall []struct {
-		arg1 context.Context
-		arg2 *livekit.EgressInfo
-	}
-	updateEgressReturns struct {
-		result1 error
-	}
-	updateEgressReturnsOnCall map[int]struct {
-		result1 error
-	}
-	UpdateIngressStub        func(context.Context, *livekit.IngressInfo) error
-	updateIngressMutex       sync.RWMutex
-	updateIngressArgsForCall []struct {
-		arg1 context.Context
-		arg2 *livekit.IngressInfo
-	}
-	updateIngressReturns struct {
-		result1 error
-	}
-	updateIngressReturnsOnCall map[int]struct {
-		result1 error
-	}
 	invocations      map[string][][]interface{}
 	invocationsMutex sync.RWMutex
 }

-func (fake *FakeServiceStore) DeleteEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error {
-	fake.deleteEgressMutex.Lock()
-	ret, specificReturn := fake.deleteEgressReturnsOnCall[len(fake.deleteEgressArgsForCall)]
-	fake.deleteEgressArgsForCall = append(fake.deleteEgressArgsForCall, struct {
-		arg1 context.Context
-		arg2 *livekit.EgressInfo
-	}{arg1, arg2})
-	stub := fake.DeleteEgressStub
-	fakeReturns := fake.deleteEgressReturns
-	fake.recordInvocation("DeleteEgress", []interface{}{arg1, arg2})
-	fake.deleteEgressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *FakeServiceStore) DeleteEgressCallCount() int {
-	fake.deleteEgressMutex.RLock()
-	defer fake.deleteEgressMutex.RUnlock()
-	return len(fake.deleteEgressArgsForCall)
-}
-
-func (fake *FakeServiceStore) DeleteEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) {
-	fake.deleteEgressMutex.Lock()
-	defer fake.deleteEgressMutex.Unlock()
-	fake.DeleteEgressStub = stub
-}
-
-func (fake *FakeServiceStore) DeleteEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) {
-	fake.deleteEgressMutex.RLock()
-	defer fake.deleteEgressMutex.RUnlock()
-	argsForCall := fake.deleteEgressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeServiceStore) DeleteEgressReturns(result1 error) {
-	fake.deleteEgressMutex.Lock()
-	defer fake.deleteEgressMutex.Unlock()
-	fake.DeleteEgressStub = nil
-	fake.deleteEgressReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeServiceStore) DeleteEgressReturnsOnCall(i int, result1 error) {
-	fake.deleteEgressMutex.Lock()
-	defer fake.deleteEgressMutex.Unlock()
-	fake.DeleteEgressStub = nil
-	if fake.deleteEgressReturnsOnCall == nil {
-		fake.deleteEgressReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.deleteEgressReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeServiceStore) DeleteIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error {
-	fake.deleteIngressMutex.Lock()
-	ret, specificReturn := fake.deleteIngressReturnsOnCall[len(fake.deleteIngressArgsForCall)]
-	fake.deleteIngressArgsForCall = append(fake.deleteIngressArgsForCall, struct {
-		arg1 context.Context
-		arg2 *livekit.IngressInfo
-	}{arg1, arg2})
-	stub := fake.DeleteIngressStub
-	fakeReturns := fake.deleteIngressReturns
-	fake.recordInvocation("DeleteIngress", []interface{}{arg1, arg2})
-	fake.deleteIngressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *FakeServiceStore) DeleteIngressCallCount() int {
-	fake.deleteIngressMutex.RLock()
-	defer fake.deleteIngressMutex.RUnlock()
-	return len(fake.deleteIngressArgsForCall)
-}
-
-func (fake *FakeServiceStore) DeleteIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) {
-	fake.deleteIngressMutex.Lock()
-	defer fake.deleteIngressMutex.Unlock()
-	fake.DeleteIngressStub = stub
-}
-
-func (fake *FakeServiceStore) DeleteIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) {
-	fake.deleteIngressMutex.RLock()
-	defer fake.deleteIngressMutex.RUnlock()
-	argsForCall := fake.deleteIngressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeServiceStore) DeleteIngressReturns(result1 error) {
-	fake.deleteIngressMutex.Lock()
-	defer fake.deleteIngressMutex.Unlock()
-	fake.DeleteIngressStub = nil
-	fake.deleteIngressReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeServiceStore) DeleteIngressReturnsOnCall(i int, result1 error) {
-	fake.deleteIngressMutex.Lock()
-	defer fake.deleteIngressMutex.Unlock()
-	fake.DeleteIngressStub = nil
-	if fake.deleteIngressReturnsOnCall == nil {
-		fake.deleteIngressReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.deleteIngressReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeServiceStore) ListEgress(arg1 context.Context, arg2 livekit.RoomID) ([]*livekit.EgressInfo, error) {
-	fake.listEgressMutex.Lock()
-	ret, specificReturn := fake.listEgressReturnsOnCall[len(fake.listEgressArgsForCall)]
-	fake.listEgressArgsForCall = append(fake.listEgressArgsForCall, struct {
-		arg1 context.Context
-		arg2 livekit.RoomID
-	}{arg1, arg2})
-	stub := fake.ListEgressStub
-	fakeReturns := fake.listEgressReturns
-	fake.recordInvocation("ListEgress", []interface{}{arg1, arg2})
-	fake.listEgressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeServiceStore) ListEgressCallCount() int {
-	fake.listEgressMutex.RLock()
-	defer fake.listEgressMutex.RUnlock()
-	return len(fake.listEgressArgsForCall)
-}
-
-func (fake *FakeServiceStore) ListEgressCalls(stub func(context.Context, livekit.RoomID) ([]*livekit.EgressInfo, error)) {
-	fake.listEgressMutex.Lock()
-	defer fake.listEgressMutex.Unlock()
-	fake.ListEgressStub = stub
-}
-
-func (fake *FakeServiceStore) ListEgressArgsForCall(i int) (context.Context, livekit.RoomID) {
-	fake.listEgressMutex.RLock()
-	defer fake.listEgressMutex.RUnlock()
-	argsForCall := fake.listEgressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeServiceStore) ListEgressReturns(result1 []*livekit.EgressInfo, result2 error) {
-	fake.listEgressMutex.Lock()
-	defer fake.listEgressMutex.Unlock()
-	fake.ListEgressStub = nil
-	fake.listEgressReturns = struct {
-		result1 []*livekit.EgressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeServiceStore) ListEgressReturnsOnCall(i int, result1 []*livekit.EgressInfo, result2 error) {
-	fake.listEgressMutex.Lock()
-	defer fake.listEgressMutex.Unlock()
-	fake.ListEgressStub = nil
-	if fake.listEgressReturnsOnCall == nil {
-		fake.listEgressReturnsOnCall = make(map[int]struct {
-			result1 []*livekit.EgressInfo
-			result2 error
-		})
-	}
-	fake.listEgressReturnsOnCall[i] = struct {
-		result1 []*livekit.EgressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeServiceStore) ListIngress(arg1 context.Context, arg2 livekit.RoomName) ([]*livekit.IngressInfo, error) {
-	fake.listIngressMutex.Lock()
-	ret, specificReturn := fake.listIngressReturnsOnCall[len(fake.listIngressArgsForCall)]
-	fake.listIngressArgsForCall = append(fake.listIngressArgsForCall, struct {
-		arg1 context.Context
-		arg2 livekit.RoomName
-	}{arg1, arg2})
-	stub := fake.ListIngressStub
-	fakeReturns := fake.listIngressReturns
-	fake.recordInvocation("ListIngress", []interface{}{arg1, arg2})
-	fake.listIngressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeServiceStore) ListIngressCallCount() int {
-	fake.listIngressMutex.RLock()
-	defer fake.listIngressMutex.RUnlock()
-	return len(fake.listIngressArgsForCall)
-}
-
-func (fake *FakeServiceStore) ListIngressCalls(stub func(context.Context, livekit.RoomName) ([]*livekit.IngressInfo, error)) {
-	fake.listIngressMutex.Lock()
-	defer fake.listIngressMutex.Unlock()
-	fake.ListIngressStub = stub
-}
-
-func (fake *FakeServiceStore) ListIngressArgsForCall(i int) (context.Context, livekit.RoomName) {
-	fake.listIngressMutex.RLock()
-	defer fake.listIngressMutex.RUnlock()
-	argsForCall := fake.listIngressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeServiceStore) ListIngressReturns(result1 []*livekit.IngressInfo, result2 error) {
-	fake.listIngressMutex.Lock()
-	defer fake.listIngressMutex.Unlock()
-	fake.ListIngressStub = nil
-	fake.listIngressReturns = struct {
-		result1 []*livekit.IngressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeServiceStore) ListIngressReturnsOnCall(i int, result1 []*livekit.IngressInfo, result2 error) {
-	fake.listIngressMutex.Lock()
-	defer fake.listIngressMutex.Unlock()
-	fake.ListIngressStub = nil
-	if fake.listIngressReturnsOnCall == nil {
-		fake.listIngressReturnsOnCall = make(map[int]struct {
-			result1 []*livekit.IngressInfo
-			result2 error
-		})
-	}
-	fake.listIngressReturnsOnCall[i] = struct {
-		result1 []*livekit.IngressInfo
-		result2 error
-	}{result1, result2}
-}
-
 func (fake *FakeServiceStore) ListParticipants(arg1 context.Context, arg2 livekit.RoomName) ([]*livekit.ParticipantInfo, error) {
 	fake.listParticipantsMutex.Lock()
 	ret, specificReturn := fake.listParticipantsReturnsOnCall[len(fake.listParticipantsArgsForCall)]
@@ -602,201 +206,6 @@ func (fake *FakeServiceStore) ListRoomsReturnsOnCall(i int, result1 []*livekit.R
 	}{result1, result2}
 }

-func (fake *FakeServiceStore) LoadEgress(arg1 context.Context, arg2 string) (*livekit.EgressInfo, error) {
-	fake.loadEgressMutex.Lock()
-	ret, specificReturn := fake.loadEgressReturnsOnCall[len(fake.loadEgressArgsForCall)]
-	fake.loadEgressArgsForCall = append(fake.loadEgressArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-	}{arg1, arg2})
-	stub := fake.LoadEgressStub
-	fakeReturns := fake.loadEgressReturns
-	fake.recordInvocation("LoadEgress", []interface{}{arg1, arg2})
-	fake.loadEgressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeServiceStore) LoadEgressCallCount() int {
-	fake.loadEgressMutex.RLock()
-	defer fake.loadEgressMutex.RUnlock()
-	return len(fake.loadEgressArgsForCall)
-}
-
-func (fake *FakeServiceStore) LoadEgressCalls(stub func(context.Context, string) (*livekit.EgressInfo, error)) {
-	fake.loadEgressMutex.Lock()
-	defer fake.loadEgressMutex.Unlock()
-	fake.LoadEgressStub = stub
-}
-
-func (fake *FakeServiceStore) LoadEgressArgsForCall(i int) (context.Context, string) {
-	fake.loadEgressMutex.RLock()
-	defer fake.loadEgressMutex.RUnlock()
-	argsForCall := fake.loadEgressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeServiceStore) LoadEgressReturns(result1 *livekit.EgressInfo, result2 error) {
-	fake.loadEgressMutex.Lock()
-	defer fake.loadEgressMutex.Unlock()
-	fake.LoadEgressStub = nil
-	fake.loadEgressReturns = struct {
-		result1 *livekit.EgressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeServiceStore) LoadEgressReturnsOnCall(i int, result1 *livekit.EgressInfo, result2 error) {
-	fake.loadEgressMutex.Lock()
-	defer fake.loadEgressMutex.Unlock()
-	fake.LoadEgressStub = nil
-	if fake.loadEgressReturnsOnCall == nil {
-		fake.loadEgressReturnsOnCall = make(map[int]struct {
-			result1 *livekit.EgressInfo
-			result2 error
-		})
-	}
-	fake.loadEgressReturnsOnCall[i] = struct {
-		result1 *livekit.EgressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeServiceStore) LoadIngress(arg1 context.Context, arg2 string) (*livekit.IngressInfo, error) {
-	fake.loadIngressMutex.Lock()
-	ret, specificReturn := fake.loadIngressReturnsOnCall[len(fake.loadIngressArgsForCall)]
-	fake.loadIngressArgsForCall = append(fake.loadIngressArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-	}{arg1, arg2})
-	stub := fake.LoadIngressStub
-	fakeReturns := fake.loadIngressReturns
-	fake.recordInvocation("LoadIngress", []interface{}{arg1, arg2})
-	fake.loadIngressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeServiceStore) LoadIngressCallCount() int {
-	fake.loadIngressMutex.RLock()
-	defer fake.loadIngressMutex.RUnlock()
-	return len(fake.loadIngressArgsForCall)
-}
-
-func (fake *FakeServiceStore) LoadIngressCalls(stub func(context.Context, string) (*livekit.IngressInfo, error)) {
-	fake.loadIngressMutex.Lock()
-	defer fake.loadIngressMutex.Unlock()
-	fake.LoadIngressStub = stub
-}
-
-func (fake *FakeServiceStore) LoadIngressArgsForCall(i int) (context.Context, string) {
-	fake.loadIngressMutex.RLock()
-	defer fake.loadIngressMutex.RUnlock()
-	argsForCall := fake.loadIngressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeServiceStore) LoadIngressReturns(result1 *livekit.IngressInfo, result2 error) {
-	fake.loadIngressMutex.Lock()
-	defer fake.loadIngressMutex.Unlock()
-	fake.LoadIngressStub = nil
-	fake.loadIngressReturns = struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeServiceStore) LoadIngressReturnsOnCall(i int, result1 *livekit.IngressInfo, result2 error) {
-	fake.loadIngressMutex.Lock()
-	defer fake.loadIngressMutex.Unlock()
-	fake.LoadIngressStub = nil
-	if fake.loadIngressReturnsOnCall == nil {
-		fake.loadIngressReturnsOnCall = make(map[int]struct {
-			result1 *livekit.IngressInfo
-			result2 error
-		})
-	}
-	fake.loadIngressReturnsOnCall[i] = struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeServiceStore) LoadIngressFromStreamKey(arg1 context.Context, arg2 string) (*livekit.IngressInfo, error) {
-	fake.loadIngressFromStreamKeyMutex.Lock()
-	ret, specificReturn := fake.loadIngressFromStreamKeyReturnsOnCall[len(fake.loadIngressFromStreamKeyArgsForCall)]
-	fake.loadIngressFromStreamKeyArgsForCall = append(fake.loadIngressFromStreamKeyArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-	}{arg1, arg2})
-	stub := fake.LoadIngressFromStreamKeyStub
-	fakeReturns := fake.loadIngressFromStreamKeyReturns
-	fake.recordInvocation("LoadIngressFromStreamKey", []interface{}{arg1, arg2})
-	fake.loadIngressFromStreamKeyMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *FakeServiceStore) LoadIngressFromStreamKeyCallCount() int {
-	fake.loadIngressFromStreamKeyMutex.RLock()
-	defer fake.loadIngressFromStreamKeyMutex.RUnlock()
-	return len(fake.loadIngressFromStreamKeyArgsForCall)
-}
-
-func (fake *FakeServiceStore) LoadIngressFromStreamKeyCalls(stub func(context.Context, string) (*livekit.IngressInfo, error)) {
-	fake.loadIngressFromStreamKeyMutex.Lock()
-	defer fake.loadIngressFromStreamKeyMutex.Unlock()
-	fake.LoadIngressFromStreamKeyStub = stub
-}
-
-func (fake *FakeServiceStore) LoadIngressFromStreamKeyArgsForCall(i int) (context.Context, string) {
-	fake.loadIngressFromStreamKeyMutex.RLock()
-	defer fake.loadIngressFromStreamKeyMutex.RUnlock()
-	argsForCall := fake.loadIngressFromStreamKeyArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeServiceStore) LoadIngressFromStreamKeyReturns(result1 *livekit.IngressInfo, result2 error) {
-	fake.loadIngressFromStreamKeyMutex.Lock()
-	defer fake.loadIngressFromStreamKeyMutex.Unlock()
-	fake.LoadIngressFromStreamKeyStub = nil
-	fake.loadIngressFromStreamKeyReturns = struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *FakeServiceStore) LoadIngressFromStreamKeyReturnsOnCall(i int, result1 *livekit.IngressInfo, result2 error) {
-	fake.loadIngressFromStreamKeyMutex.Lock()
-	defer fake.loadIngressFromStreamKeyMutex.Unlock()
-	fake.LoadIngressFromStreamKeyStub = nil
-	if fake.loadIngressFromStreamKeyReturnsOnCall == nil {
-		fake.loadIngressFromStreamKeyReturnsOnCall = make(map[int]struct {
-			result1 *livekit.IngressInfo
-			result2 error
-		})
-	}
-	fake.loadIngressFromStreamKeyReturnsOnCall[i] = struct {
-		result1 *livekit.IngressInfo
-		result2 error
-	}{result1, result2}
-}
-
 func (fake *FakeServiceStore) LoadParticipant(arg1 context.Context, arg2 livekit.RoomName, arg3 livekit.ParticipantIdentity) (*livekit.ParticipantInfo, error) {
 	fake.loadParticipantMutex.Lock()
 	ret, specificReturn := fake.loadParticipantReturnsOnCall[len(fake.loadParticipantArgsForCall)]
@@ -928,287 +337,17 @@ func (fake *FakeServiceStore) LoadRoomReturnsOnCall(i int, result1 *livekit.Room
 	}{result1, result2}
 }

-func (fake *FakeServiceStore) StoreEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error {
-	fake.storeEgressMutex.Lock()
-	ret, specificReturn := fake.storeEgressReturnsOnCall[len(fake.storeEgressArgsForCall)]
-	fake.storeEgressArgsForCall = append(fake.storeEgressArgsForCall, struct {
-		arg1 context.Context
-		arg2 *livekit.EgressInfo
-	}{arg1, arg2})
-	stub := fake.StoreEgressStub
-	fakeReturns := fake.storeEgressReturns
-	fake.recordInvocation("StoreEgress", []interface{}{arg1, arg2})
-	fake.storeEgressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *FakeServiceStore) StoreEgressCallCount() int {
-	fake.storeEgressMutex.RLock()
-	defer fake.storeEgressMutex.RUnlock()
-	return len(fake.storeEgressArgsForCall)
-}
-
-func (fake *FakeServiceStore) StoreEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) {
-	fake.storeEgressMutex.Lock()
-	defer fake.storeEgressMutex.Unlock()
-	fake.StoreEgressStub = stub
-}
-
-func (fake *FakeServiceStore) StoreEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) {
-	fake.storeEgressMutex.RLock()
-	defer fake.storeEgressMutex.RUnlock()
-	argsForCall := fake.storeEgressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeServiceStore) StoreEgressReturns(result1 error) {
-	fake.storeEgressMutex.Lock()
-	defer fake.storeEgressMutex.Unlock()
-	fake.StoreEgressStub = nil
-	fake.storeEgressReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeServiceStore) StoreEgressReturnsOnCall(i int, result1 error) {
-	fake.storeEgressMutex.Lock()
-	defer fake.storeEgressMutex.Unlock()
-	fake.StoreEgressStub = nil
-	if fake.storeEgressReturnsOnCall == nil {
-		fake.storeEgressReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.storeEgressReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeServiceStore) StoreIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error {
-	fake.storeIngressMutex.Lock()
-	ret, specificReturn := fake.storeIngressReturnsOnCall[len(fake.storeIngressArgsForCall)]
-	fake.storeIngressArgsForCall = append(fake.storeIngressArgsForCall, struct {
-		arg1 context.Context
-		arg2 *livekit.IngressInfo
-	}{arg1, arg2})
-	stub := fake.StoreIngressStub
-	fakeReturns := fake.storeIngressReturns
-	fake.recordInvocation("StoreIngress", []interface{}{arg1, arg2})
-	fake.storeIngressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *FakeServiceStore) StoreIngressCallCount() int {
-	fake.storeIngressMutex.RLock()
-	defer fake.storeIngressMutex.RUnlock()
-	return len(fake.storeIngressArgsForCall)
-}
-
-func (fake *FakeServiceStore) StoreIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) {
-	fake.storeIngressMutex.Lock()
-	defer fake.storeIngressMutex.Unlock()
-	fake.StoreIngressStub = stub
-}
-
-func (fake *FakeServiceStore) StoreIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) {
-	fake.storeIngressMutex.RLock()
-	defer fake.storeIngressMutex.RUnlock()
-	argsForCall := fake.storeIngressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeServiceStore) StoreIngressReturns(result1 error) {
-	fake.storeIngressMutex.Lock()
-	defer fake.storeIngressMutex.Unlock()
-	fake.StoreIngressStub = nil
-	fake.storeIngressReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeServiceStore) StoreIngressReturnsOnCall(i int, result1 error) {
-	fake.storeIngressMutex.Lock()
-	defer fake.storeIngressMutex.Unlock()
-	fake.StoreIngressStub = nil
-	if fake.storeIngressReturnsOnCall == nil {
-		fake.storeIngressReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.storeIngressReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeServiceStore) UpdateEgress(arg1 context.Context, arg2 *livekit.EgressInfo) error {
-	fake.updateEgressMutex.Lock()
-	ret, specificReturn := fake.updateEgressReturnsOnCall[len(fake.updateEgressArgsForCall)]
-	fake.updateEgressArgsForCall = append(fake.updateEgressArgsForCall, struct {
-		arg1 context.Context
-		arg2 *livekit.EgressInfo
-	}{arg1, arg2})
-	stub := fake.UpdateEgressStub
-	fakeReturns := fake.updateEgressReturns
-	fake.recordInvocation("UpdateEgress", []interface{}{arg1, arg2})
-	fake.updateEgressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *FakeServiceStore) UpdateEgressCallCount() int {
-	fake.updateEgressMutex.RLock()
-	defer fake.updateEgressMutex.RUnlock()
-	return len(fake.updateEgressArgsForCall)
-}
-
-func (fake *FakeServiceStore) UpdateEgressCalls(stub func(context.Context, *livekit.EgressInfo) error) {
-	fake.updateEgressMutex.Lock()
-	defer fake.updateEgressMutex.Unlock()
-	fake.UpdateEgressStub = stub
-}
-
-func (fake *FakeServiceStore) UpdateEgressArgsForCall(i int) (context.Context, *livekit.EgressInfo) {
-	fake.updateEgressMutex.RLock()
-	defer fake.updateEgressMutex.RUnlock()
-	argsForCall := fake.updateEgressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeServiceStore) UpdateEgressReturns(result1 error) {
-	fake.updateEgressMutex.Lock()
-	defer fake.updateEgressMutex.Unlock()
-	fake.UpdateEgressStub = nil
-	fake.updateEgressReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeServiceStore) UpdateEgressReturnsOnCall(i int, result1 error) {
-	fake.updateEgressMutex.Lock()
-	defer fake.updateEgressMutex.Unlock()
-	fake.UpdateEgressStub = nil
-	if fake.updateEgressReturnsOnCall == nil {
-		fake.updateEgressReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.updateEgressReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeServiceStore) UpdateIngress(arg1 context.Context, arg2 *livekit.IngressInfo) error {
-	fake.updateIngressMutex.Lock()
-	ret, specificReturn := fake.updateIngressReturnsOnCall[len(fake.updateIngressArgsForCall)]
-	fake.updateIngressArgsForCall = append(fake.updateIngressArgsForCall, struct {
-		arg1 context.Context
-		arg2 *livekit.IngressInfo
-	}{arg1, arg2})
-	stub := fake.UpdateIngressStub
-	fakeReturns := fake.updateIngressReturns
-	fake.recordInvocation("UpdateIngress", []interface{}{arg1, arg2})
-	fake.updateIngressMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *FakeServiceStore) UpdateIngressCallCount() int {
-	fake.updateIngressMutex.RLock()
-	defer fake.updateIngressMutex.RUnlock()
-	return len(fake.updateIngressArgsForCall)
-}
-
-func (fake *FakeServiceStore) UpdateIngressCalls(stub func(context.Context, *livekit.IngressInfo) error) {
-	fake.updateIngressMutex.Lock()
-	defer fake.updateIngressMutex.Unlock()
-	fake.UpdateIngressStub = stub
-}
-
-func (fake *FakeServiceStore) UpdateIngressArgsForCall(i int) (context.Context, *livekit.IngressInfo) {
-	fake.updateIngressMutex.RLock()
-	defer fake.updateIngressMutex.RUnlock()
-	argsForCall := fake.updateIngressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *FakeServiceStore) UpdateIngressReturns(result1 error) {
-	fake.updateIngressMutex.Lock()
-	defer fake.updateIngressMutex.Unlock()
-	fake.UpdateIngressStub = nil
-	fake.updateIngressReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *FakeServiceStore) UpdateIngressReturnsOnCall(i int, result1 error) {
-	fake.updateIngressMutex.Lock()
-	defer fake.updateIngressMutex.Unlock()
-	fake.UpdateIngressStub = nil
-	if fake.updateIngressReturnsOnCall == nil {
-		fake.updateIngressReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.updateIngressReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
 func (fake *FakeServiceStore) Invocations() map[string][][]interface{} {
 	fake.invocationsMutex.RLock()
 	defer fake.invocationsMutex.RUnlock()
-	fake.deleteEgressMutex.RLock()
-	defer fake.deleteEgressMutex.RUnlock()
-	fake.deleteIngressMutex.RLock()
-	defer fake.deleteIngressMutex.RUnlock()
-	fake.listEgressMutex.RLock()
-	defer fake.listEgressMutex.RUnlock()
-	fake.listIngressMutex.RLock()
-	defer fake.listIngressMutex.RUnlock()
 	fake.listParticipantsMutex.RLock()
 	defer fake.listParticipantsMutex.RUnlock()
 	fake.listRoomsMutex.RLock()
 	defer fake.listRoomsMutex.RUnlock()
-	fake.loadEgressMutex.RLock()
-	defer fake.loadEgressMutex.RUnlock()
-	fake.loadIngressMutex.RLock()
-	defer fake.loadIngressMutex.RUnlock()
-	fake.loadIngressFromStreamKeyMutex.RLock()
-	defer fake.loadIngressFromStreamKeyMutex.RUnlock()
 	fake.loadParticipantMutex.RLock()
 	defer fake.loadParticipantMutex.RUnlock()
 	fake.loadRoomMutex.RLock()
 	defer fake.loadRoomMutex.RUnlock()
-	fake.storeEgressMutex.RLock()
-	defer fake.storeEgressMutex.RUnlock()
-	fake.storeIngressMutex.RLock()
-	defer fake.storeIngressMutex.RUnlock()
-	fake.updateEgressMutex.RLock()
-	defer fake.updateEgressMutex.RUnlock()
-	fake.updateIngressMutex.RLock()
-	defer fake.updateIngressMutex.RUnlock()
 	copiedInvocations := map[string][][]interface{}{}
 	for key, value := range fake.invocations {
 		copiedInvocations[key] = value
@@ -42,6 +42,7 @@ func InitializeServer(conf *config.Config, currentNode routing.LocalNode) (*Live
 		telemetry.NewAnalyticsService,
 		telemetry.NewTelemetryService,
 		egress.NewRedisRPCClient,
+		getEgressStore,
 		NewEgressService,
 		NewRoomAllocator,
 		NewRoomService,
@@ -165,6 +166,17 @@ func createStore(rc *redis.Client) ObjectStore {
 	return NewLocalStore()
 }

+func getEgressStore(s ObjectStore) EgressStore {
+	switch store := s.(type) {
+	case *RedisStore:
+		return store
+	case *LocalStore:
+		return store
+	default:
+		return nil
+	}
+}
+
 func createClientConfiguration() clientconfiguration.ClientConfigurationManager {
 	return clientconfiguration.NewStaticClientConfigurationManager(clientconfiguration.StaticConfigurations)
 }
@@ -49,6 +49,7 @@ func InitializeServer(conf *config.Config, currentNode routing.LocalNode) (*Live
 	}
 	nodeID := getNodeID(currentNode)
 	rpcClient := egress.NewRedisRPCClient(nodeID, client)
+	egressStore := getEgressStore(objectStore)
 	keyProvider, err := createKeyProvider(conf)
 	if err != nil {
 		return nil, err
@@ -59,7 +60,7 @@ func InitializeServer(conf *config.Config, currentNode routing.LocalNode) (*Live
 	}
 	analyticsService := telemetry.NewAnalyticsService(conf, currentNode)
 	telemetryService := telemetry.NewTelemetryService(notifier, analyticsService)
-	egressService := NewEgressService(rpcClient, objectStore, roomService, telemetryService)
+	egressService := NewEgressService(rpcClient, objectStore, egressStore, roomService, telemetryService)
 	rtcService := NewRTCService(conf, roomAllocator, objectStore, router, currentNode)
 	clientConfigurationManager := createClientConfiguration()
 	roomManager, err := NewLocalRoomManager(conf, objectStore, currentNode, router, telemetryService, clientConfigurationManager)
@@ -191,6 +192,17 @@ func createStore(rc *redis.Client) ObjectStore {
 	return NewLocalStore()
 }

+func getEgressStore(s ObjectStore) EgressStore {
+	switch store := s.(type) {
+	case *RedisStore:
+		return store
+	case *LocalStore:
+		return store
+	default:
+		return nil
+	}
+}
+
 func createClientConfiguration() clientconfiguration.ClientConfigurationManager {
 	return clientconfiguration.NewStaticClientConfigurationManager(clientconfiguration.StaticConfigurations)
 }