Altitude/AltitudeWeb
5
0
Fork 0
Code Issues 12 Pull Requests Actions Packages Projects Releases Wiki Activity

Add ServerMessageService for broadcasting player state updates, implement PlayerListState model, and update ChatService to synchronize active player states across servers.

Browse Source
This commit is contained in:
stijn
2026-08-22 19:27:02 +02:00
parent 2a65f98493
commit 8a61d35e63
11 changed files with 323 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/src/main/java/com/alttd/altitudeweb/config/SecurityConfig.java
+3
View File
@@ -62,6 +62,9 @@ public class SecurityConfig {
.requestMatchers("/api/mail/**").authenticated()
.requestMatchers("/api/site/vote").authenticated()
.requestMatchers("/api/appeal").authenticated()
.requestMatchers(HttpMethod.POST, "/api/chat/hide").hasAuthority(PermissionClaimDto.HEAD_MOD.getValue())
.requestMatchers(HttpMethod.POST, "/api/chat/show").hasAuthority(PermissionClaimDto.HEAD_MOD.getValue())
.requestMatchers(HttpMethod.GET, "/api/chat/visibility").hasAuthority(PermissionClaimDto.HEAD_MOD.getValue())
.requestMatchers("/api/chat/read/**").hasAnyAuthority(PermissionClaimDto.HEAD_MOD.getValue(), PermissionClaimDto.MOD.getValue())
.requestMatchers("/api/site/get-staff-playtime/**").hasAuthority(PermissionClaimDto.HEAD_MOD.getValue())
.requestMatchers("/api/head_mod/**").hasAuthority(PermissionClaimDto.HEAD_MOD.getValue())
backend/src/main/java/com/alttd/altitudeweb/controllers/chat/ChatController.java
+26
View File
@@ -1,7 +1,9 @@
package com.alttd.altitudeweb.controllers.chat;
import com.alttd.altitudeweb.api.ChatApi;
import com.alttd.altitudeweb.controllers.data_from_auth.AuthenticatedUuid;
import com.alttd.altitudeweb.model.ChatMessageDto;
import com.alttd.altitudeweb.model.PlayerListVisibilityDto;
import com.alttd.altitudeweb.model.ServerStateDto;
import com.alttd.altitudeweb.services.chat.ChatService;
import lombok.RequiredArgsConstructor;
@@ -11,6 +13,7 @@ import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.UUID;
@Slf4j
@RestController
@@ -18,6 +21,29 @@ import java.util.List;
public class ChatController implements ChatApi {
private final ChatService chatService;
private final AuthenticatedUuid authenticatedUuid;
@Override
public ResponseEntity<Void> hideUserFromPlayerList() {
UUID uuid = authenticatedUuid.getAuthenticatedUserUuid();
chatService.hideUserFromPlayerList(uuid);
return new ResponseEntity<>(HttpStatus.NO_CONTENT);
}
@Override
public ResponseEntity<Void> showUserInPlayerList() {
UUID uuid = authenticatedUuid.getAuthenticatedUserUuid();
chatService.showUserInPlayerList(uuid);
return new ResponseEntity<>(HttpStatus.NO_CONTENT);
}
@Override
public ResponseEntity<PlayerListVisibilityDto> getPlayerListVisibility() {
UUID uuid = authenticatedUuid.getAuthenticatedUserUuid();
PlayerListVisibilityDto visibility = new PlayerListVisibilityDto()
.hidden(chatService.isUserHiddenFromPlayerList(uuid));
return ResponseEntity.ok(visibility);
}
@Override
public ResponseEntity<Void> sendChatMessages(List<ChatMessageDto> chatMessageDtoList) {
backend/src/main/java/com/alttd/altitudeweb/services/chat/ChatService.java
+34
View File
@@ -23,6 +23,8 @@ import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.http.HttpStatus;
import org.springframework.web.server.ResponseStatusException;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
import java.time.Duration;
@@ -41,6 +43,7 @@ public class ChatService {
private final ServerMessageService serverMessageService;
private final NavigableMap<Instant, ChatMessage> chatMessages = new TreeMap<>();
private final Map<String, EventUser> eventUserMap = new ConcurrentHashMap<>();
private final Set<UUID> hiddenUsers = ConcurrentHashMap.newKeySet();
private final Map<String, ServerDto> serverStateCache = new HashMap<>();
@Value("${chat.allowed-servers}")
@@ -100,13 +103,44 @@ public class ChatService {
saveSession(chatSession);
if (!eventPublisher.hasSubscribers(key) && eventUserMap.remove(key, eventUser)) {
hiddenUsers.remove(eventUser.uuid());
sendPlayerStateToServers();
}
}
public synchronized void hideUserFromPlayerList(UUID uuid) {
requireActiveHeadMod(uuid);
if (hiddenUsers.add(uuid)) {
sendPlayerStateToServers();
}
}
public synchronized void showUserInPlayerList(UUID uuid) {
requireActiveHeadMod(uuid);
if (hiddenUsers.remove(uuid)) {
sendPlayerStateToServers();
}
}
public synchronized boolean isUserHiddenFromPlayerList(UUID uuid) {
requireActiveHeadMod(uuid);
return hiddenUsers.contains(uuid);
}
private void requireActiveHeadMod(UUID uuid) {
EventUser eventUser = eventUserMap.get(uuid.toString());
if (eventUser == null) {
throw new ResponseStatusException(HttpStatus.CONFLICT, "No active chat session");
}
if (!eventUser.hasPermission(PermissionClaimDto.HEAD_MOD)) {
throw new ResponseStatusException(HttpStatus.FORBIDDEN, "Only head moderators can change session visibility");
}
}
private void sendPlayerStateToServers() {
ArrayList<UUID> activePlayers = eventUserMap.values().stream()
.map(EventUser::uuid)
.filter(uuid -> !hiddenUsers.contains(uuid))
.collect(Collectors.toCollection(ArrayList::new));
serverMessageService.sendMessageToAll("player_state", PlayerListStateMapper.fromList(activePlayers));
}
backend/src/main/java/com/alttd/altitudeweb/services/chat/event_publisher/EventPublisher.java
+19 -8
View File
@@ -9,11 +9,11 @@ import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
import java.io.IOException;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* Generic SSE event publisher, keyed by an arbitrary "unique" string
@@ -28,6 +28,7 @@ import java.util.concurrent.CopyOnWriteArrayList;
public class EventPublisher {
private final Map<String, List<SseEmitter>> emitterMap = new ConcurrentHashMap<>();
private final Map<SseEmitter, Runnable> emitterCleanupMap = new ConcurrentHashMap<>();
/**
* Invoked once a given emitter for uniqueKey is cleaned up (completed,
@@ -49,7 +50,13 @@ public class EventPublisher {
Instant sessionStart = Instant.now();
log.info("Key {} subscribed, active emitters: {}", uniqueKey, countActive());
Runnable cleanup = () -> handleCleanup(uniqueKey, emitter, sessionStart, cleanupCallback);
AtomicBoolean cleanedUp = new AtomicBoolean();
Runnable cleanup = () -> {
if (cleanedUp.compareAndSet(false, true)) {
handleCleanup(uniqueKey, emitter, sessionStart, cleanupCallback);
}
};
emitterCleanupMap.put(emitter, cleanup);
// covers: clean disconnect (tab closed normally), server-side timeout, write failure
emitter.onCompletion(cleanup);
@@ -74,15 +81,13 @@ public class EventPublisher {
@Scheduled(fixedRate = 20_000)
public void heartbeat() {
emitterMap.values().forEach(list -> {
List<SseEmitter> dead = new ArrayList<>();
for (SseEmitter emitter : list) {
try {
emitter.send(SseEmitter.event().comment("heartbeat"));
} catch (IOException e) {
dead.add(emitter);
cleanup(emitter);
}
}
list.removeAll(dead);
});
emitterMap.entrySet().removeIf(e -> e.getValue().isEmpty());
}
@@ -93,15 +98,13 @@ public class EventPublisher {
return;
}
List<SseEmitter> dead = new ArrayList<>();
for (SseEmitter emitter : userEmitters) {
try {
emitter.send(SseEmitter.event().name(eventName).data(json));
} catch (IOException e) {
dead.add(emitter);
cleanup(emitter);
}
}
userEmitters.removeAll(dead);
}
public boolean hasSubscribers(String uniqueKey) {
@@ -113,8 +116,16 @@ public class EventPublisher {
return emitterMap.values().stream().mapToLong(List::size).sum();
}
private void cleanup(SseEmitter emitter) {
Runnable cleanup = emitterCleanupMap.get(emitter);
if (cleanup != null) {
cleanup.run();
}
}
private void handleCleanup(String uniqueKey, SseEmitter emitter, Instant sessionStart,
SessionCleanupCallback cleanupCallback) {
emitterCleanupMap.remove(emitter);
List<SseEmitter> userEmitters = emitterMap.get(uniqueKey);
if (userEmitters != null) {
userEmitters.remove(emitter);
backend/src/test/java/com/alttd/altitudeweb/controllers/chat/ChatControllerTest.java
+41
View File
@@ -1,6 +1,8 @@
package com.alttd.altitudeweb.controllers.chat;
import com.alttd.altitudeweb.controllers.data_from_auth.AuthenticatedUuid;
import com.alttd.altitudeweb.model.ServerStateDto;
import com.alttd.altitudeweb.model.PlayerListVisibilityDto;
import com.alttd.altitudeweb.services.chat.ChatService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@@ -10,6 +12,8 @@ import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import java.util.UUID;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.verify;
@@ -19,6 +23,9 @@ class ChatControllerTest {
@Mock
private ChatService chatService;
@Mock
private AuthenticatedUuid authenticatedUuid;
@InjectMocks
private ChatController chatController;
@@ -31,4 +38,38 @@ class ChatControllerTest {
verify(chatService).updateServerState(serverStateDto);
assertEquals(HttpStatus.ACCEPTED, response.getStatusCode());
}
@Test
void hideUserFromPlayerListDelegatesForAuthenticatedUser() {
UUID uuid = UUID.randomUUID();
org.mockito.Mockito.when(authenticatedUuid.getAuthenticatedUserUuid()).thenReturn(uuid);
ResponseEntity<Void> response = chatController.hideUserFromPlayerList();
verify(chatService).hideUserFromPlayerList(uuid);
assertEquals(HttpStatus.NO_CONTENT, response.getStatusCode());
}
@Test
void showUserInPlayerListDelegatesForAuthenticatedUser() {
UUID uuid = UUID.randomUUID();
org.mockito.Mockito.when(authenticatedUuid.getAuthenticatedUserUuid()).thenReturn(uuid);
ResponseEntity<Void> response = chatController.showUserInPlayerList();
verify(chatService).showUserInPlayerList(uuid);
assertEquals(HttpStatus.NO_CONTENT, response.getStatusCode());
}
@Test
void getPlayerListVisibilityReturnsBackendState() {
UUID uuid = UUID.randomUUID();
org.mockito.Mockito.when(authenticatedUuid.getAuthenticatedUserUuid()).thenReturn(uuid);
org.mockito.Mockito.when(chatService.isUserHiddenFromPlayerList(uuid)).thenReturn(true);
ResponseEntity<PlayerListVisibilityDto> response = chatController.getPlayerListVisibility();
assertEquals(HttpStatus.OK, response.getStatusCode());
assertEquals(true, response.getBody().getHidden());
}
}
backend/src/test/java/com/alttd/altitudeweb/services/chat/ChatServiceTest.java
+38
View File
@@ -14,6 +14,7 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.web.server.ResponseStatusException;
import java.time.Instant;
import java.util.List;
@@ -22,6 +23,7 @@ import java.util.UUID;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.*;
@@ -198,4 +200,40 @@ class ChatServiceTest {
verify(serverMessageService, times(1)).sendMessageToAll(eq("player_state"), stateCaptor.capture());
assertEquals(List.of(uuid), stateCaptor.getValue().getActivePlayers());
}
@Test
void headModCanHideCurrentSessionFromPlayerState() {
UUID uuid = UUID.randomUUID();
EventUser eventUser = new EventUser(uuid, List.of(PermissionClaimDto.HEAD_MOD.getValue()), null);
chatService.subscribe(eventUser, "[]");
clearInvocations(serverMessageService);
chatService.hideUserFromPlayerList(uuid);
ArgumentCaptor<PlayerListState> stateCaptor = ArgumentCaptor.forClass(PlayerListState.class);
verify(serverMessageService).sendMessageToAll(eq("player_state"), stateCaptor.capture());
assertTrue(stateCaptor.getValue().getActivePlayers().isEmpty());
assertTrue(chatService.isUserHiddenFromPlayerList(uuid));
clearInvocations(serverMessageService);
chatService.showUserInPlayerList(uuid);
verify(serverMessageService).sendMessageToAll(eq("player_state"), stateCaptor.capture());
assertEquals(List.of(uuid), stateCaptor.getValue().getActivePlayers());
assertFalse(chatService.isUserHiddenFromPlayerList(uuid));
}
@Test
void modCannotHideCurrentSessionFromPlayerState() {
UUID uuid = UUID.randomUUID();
EventUser eventUser = new EventUser(uuid, List.of(PermissionClaimDto.MOD.getValue()), null);
chatService.subscribe(eventUser, "[]");
clearInvocations(serverMessageService);
ResponseStatusException exception = assertThrows(ResponseStatusException.class,
() -> chatService.hideUserFromPlayerList(uuid));
assertEquals(403, exception.getStatusCode().value());
verifyNoInteractions(serverMessageService);
}
}