add explicit room exists servicestore op (#4175)

pkg/service/interfaces.go

@@ -44,6 +44,7 @@ type ObjectStore interface {
 //counterfeiter:generate . ServiceStore
 type ServiceStore interface {
 	LoadRoom(ctx context.Context, roomName livekit.RoomName, includeInternal bool) (*livekit.Room, *livekit.RoomInternal, error)
+	RoomExists(ctx context.Context, roomName livekit.RoomName) (bool, error)
 
 	// ListRooms returns currently active rooms. if names is not nil, it'll filter and return
 	// only rooms that match

pkg/service/localstore.go

@@ -84,6 +84,16 @@ func (s *LocalStore) LoadRoom(_ context.Context, roomName livekit.RoomName, incl
 	return room, internal, nil
 }
 
+func (s *LocalStore) RoomExists(ctx context.Context, roomName livekit.RoomName) (bool, error) {
+	_, _, err := s.LoadRoom(ctx, roomName, false)
+	if err == ErrRoomNotFound {
+		return false, nil
+	} else if err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
 func (s *LocalStore) ListRooms(_ context.Context, roomNames []livekit.RoomName) ([]*livekit.Room, error) {
 	s.lock.RLock()
 	defer s.lock.RUnlock()

pkg/service/redisstore.go

@@ -195,6 +195,16 @@ func (s *RedisStore) LoadRoom(_ context.Context, roomName livekit.RoomName, incl
 	return room, internal, nil
 }
 
+func (s *RedisStore) RoomExists(ctx context.Context, roomName livekit.RoomName) (bool, error) {
+	_, _, err := s.LoadRoom(ctx, roomName, false)
+	if err == ErrRoomNotFound {
+		return false, nil
+	} else if err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
 func (s *RedisStore) ListRooms(_ context.Context, roomNames []livekit.RoomName) ([]*livekit.Room, error) {
 	var items []string
 	var err error

pkg/service/roomservice.go

@@ -127,9 +127,11 @@ func (s *RoomService) DeleteRoom(ctx context.Context, req *livekit.DeleteRoomReq
 		return nil, twirpAuthError(err)
 	}
 
-	_, _, err := s.roomStore.LoadRoom(ctx, livekit.RoomName(req.Room), false)
+	exists, err := s.roomStore.RoomExists(ctx, livekit.RoomName(req.Room))
 	if err != nil {
 		return nil, err
+	} else if !exists {
+		return nil, ErrRoomNotFound
 	}
 
 	// ensure at least one node is available to handle the request
@@ -304,9 +306,11 @@ func (s *RoomService) UpdateRoomMetadata(ctx context.Context, req *livekit.Updat
 		return nil, twirpAuthError(err)
 	}
 
-	_, _, err := s.roomStore.LoadRoom(ctx, livekit.RoomName(req.Room), false)
+	exists, err := s.roomStore.RoomExists(ctx, livekit.RoomName(req.Room))
 	if err != nil {
 		return nil, err
+	} else if !exists {
+		return nil, ErrRoomNotFound
 	}
 
 	room, err := s.roomClient.UpdateRoomMetadata(ctx, s.topicFormatter.RoomTopic(ctx, livekit.RoomName(req.Room)), req)

pkg/service/servicefakes/fake_object_store.go

@@ -126,6 +126,20 @@ type FakeObjectStore struct {
 		result1 string
 		result2 error
 	}
+	RoomExistsStub        func(context.Context, livekit.RoomName) (bool, error)
+	roomExistsMutex       sync.RWMutex
+	roomExistsArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}
+	roomExistsReturns struct {
+		result1 bool
+		result2 error
+	}
+	roomExistsReturnsOnCall map[int]struct {
+		result1 bool
+		result2 error
+	}
 	StoreParticipantStub        func(context.Context, livekit.RoomName, *livekit.ParticipantInfo) error
 	storeParticipantMutex       sync.RWMutex
 	storeParticipantArgsForCall []struct {
@@ -696,6 +710,71 @@ func (fake *FakeObjectStore) LockRoomReturnsOnCall(i int, result1 string, result
 	}{result1, result2}
 }
 
+func (fake *FakeObjectStore) RoomExists(arg1 context.Context, arg2 livekit.RoomName) (bool, error) {
+	fake.roomExistsMutex.Lock()
+	ret, specificReturn := fake.roomExistsReturnsOnCall[len(fake.roomExistsArgsForCall)]
+	fake.roomExistsArgsForCall = append(fake.roomExistsArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}{arg1, arg2})
+	stub := fake.RoomExistsStub
+	fakeReturns := fake.roomExistsReturns
+	fake.recordInvocation("RoomExists", []interface{}{arg1, arg2})
+	fake.roomExistsMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeObjectStore) RoomExistsCallCount() int {
+	fake.roomExistsMutex.RLock()
+	defer fake.roomExistsMutex.RUnlock()
+	return len(fake.roomExistsArgsForCall)
+}
+
+func (fake *FakeObjectStore) RoomExistsCalls(stub func(context.Context, livekit.RoomName) (bool, error)) {
+	fake.roomExistsMutex.Lock()
+	defer fake.roomExistsMutex.Unlock()
+	fake.RoomExistsStub = stub
+}
+
+func (fake *FakeObjectStore) RoomExistsArgsForCall(i int) (context.Context, livekit.RoomName) {
+	fake.roomExistsMutex.RLock()
+	defer fake.roomExistsMutex.RUnlock()
+	argsForCall := fake.roomExistsArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeObjectStore) RoomExistsReturns(result1 bool, result2 error) {
+	fake.roomExistsMutex.Lock()
+	defer fake.roomExistsMutex.Unlock()
+	fake.RoomExistsStub = nil
+	fake.roomExistsReturns = struct {
+		result1 bool
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeObjectStore) RoomExistsReturnsOnCall(i int, result1 bool, result2 error) {
+	fake.roomExistsMutex.Lock()
+	defer fake.roomExistsMutex.Unlock()
+	fake.RoomExistsStub = nil
+	if fake.roomExistsReturnsOnCall == nil {
+		fake.roomExistsReturnsOnCall = make(map[int]struct {
+			result1 bool
+			result2 error
+		})
+	}
+	fake.roomExistsReturnsOnCall[i] = struct {
+		result1 bool
+		result2 error
+	}{result1, result2}
+}
+
 func (fake *FakeObjectStore) StoreParticipant(arg1 context.Context, arg2 livekit.RoomName, arg3 *livekit.ParticipantInfo) error {
 	fake.storeParticipantMutex.Lock()
 	ret, specificReturn := fake.storeParticipantReturnsOnCall[len(fake.storeParticipantArgsForCall)]

pkg/service/servicefakes/fake_service_store.go

@@ -70,6 +70,20 @@ type FakeServiceStore struct {
 		result2 *livekit.RoomInternal
 		result3 error
 	}
+	RoomExistsStub        func(context.Context, livekit.RoomName) (bool, error)
+	roomExistsMutex       sync.RWMutex
+	roomExistsArgsForCall []struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}
+	roomExistsReturns struct {
+		result1 bool
+		result2 error
+	}
+	roomExistsReturnsOnCall map[int]struct {
+		result1 bool
+		result2 error
+	}
 	invocations      map[string][][]interface{}
 	invocationsMutex sync.RWMutex
 }
@@ -344,6 +358,71 @@ func (fake *FakeServiceStore) LoadRoomReturnsOnCall(i int, result1 *livekit.Room
 	}{result1, result2, result3}
 }
 
+func (fake *FakeServiceStore) RoomExists(arg1 context.Context, arg2 livekit.RoomName) (bool, error) {
+	fake.roomExistsMutex.Lock()
+	ret, specificReturn := fake.roomExistsReturnsOnCall[len(fake.roomExistsArgsForCall)]
+	fake.roomExistsArgsForCall = append(fake.roomExistsArgsForCall, struct {
+		arg1 context.Context
+		arg2 livekit.RoomName
+	}{arg1, arg2})
+	stub := fake.RoomExistsStub
+	fakeReturns := fake.roomExistsReturns
+	fake.recordInvocation("RoomExists", []interface{}{arg1, arg2})
+	fake.roomExistsMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeServiceStore) RoomExistsCallCount() int {
+	fake.roomExistsMutex.RLock()
+	defer fake.roomExistsMutex.RUnlock()
+	return len(fake.roomExistsArgsForCall)
+}
+
+func (fake *FakeServiceStore) RoomExistsCalls(stub func(context.Context, livekit.RoomName) (bool, error)) {
+	fake.roomExistsMutex.Lock()
+	defer fake.roomExistsMutex.Unlock()
+	fake.RoomExistsStub = stub
+}
+
+func (fake *FakeServiceStore) RoomExistsArgsForCall(i int) (context.Context, livekit.RoomName) {
+	fake.roomExistsMutex.RLock()
+	defer fake.roomExistsMutex.RUnlock()
+	argsForCall := fake.roomExistsArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeServiceStore) RoomExistsReturns(result1 bool, result2 error) {
+	fake.roomExistsMutex.Lock()
+	defer fake.roomExistsMutex.Unlock()
+	fake.RoomExistsStub = nil
+	fake.roomExistsReturns = struct {
+		result1 bool
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeServiceStore) RoomExistsReturnsOnCall(i int, result1 bool, result2 error) {
+	fake.roomExistsMutex.Lock()
+	defer fake.roomExistsMutex.Unlock()
+	fake.RoomExistsStub = nil
+	if fake.roomExistsReturnsOnCall == nil {
+		fake.roomExistsReturnsOnCall = make(map[int]struct {
+			result1 bool
+			result2 error
+		})
+	}
+	fake.roomExistsReturnsOnCall[i] = struct {
+		result1 bool
+		result2 error
+	}{result1, result2}
+}
+
 func (fake *FakeServiceStore) Invocations() map[string][][]interface{} {
 	fake.invocationsMutex.RLock()
 	defer fake.invocationsMutex.RUnlock()