base of lab 4

This commit is contained in:
2026-11-10 17:12:13 +03:00
parent 276dbdad8a
commit 1ec85a2402
78 changed files with 6133 additions and 0 deletions
@@ -0,0 +1,63 @@
package com.vnp.demo;
import org.springframework.http.HttpStatus;
public class BusinessException extends RuntimeException {
private final String code;
private final HttpStatus status;
public BusinessException(String code, String message, HttpStatus status) {
super(message);
this.code = code;
this.status = status;
}
public String getCode() {
return code;
}
public HttpStatus getStatus() {
return status;
}
public static BusinessException notFound() {
return new BusinessException(
"not_found",
"Объект не найден",
HttpStatus.NOT_FOUND
);
}
public static BusinessException conflict() {
return conflict("Конфликт");
}
public static BusinessException conflict(String message) {
return new BusinessException(
"conflict",
message,
HttpStatus.CONFLICT
);
}
public static BusinessException unauthorized() {
return unauthorized("Пользователь не найден");
}
public static BusinessException unauthorized(String message) {
return new BusinessException(
"unauthorized",
message,
HttpStatus.UNAUTHORIZED
);
}
public static BusinessException invalid(String message) {
return new BusinessException(
"invalid_request",
message,
HttpStatus.BAD_REQUEST
);
}
}
@@ -0,0 +1,184 @@
package com.vnp.demo;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.time.format.DateTimeParseException;
import java.util.Base64;
import java.util.UUID;
import org.springframework.stereotype.Component;
@Component
public class CursorCodec {
public record ChatCursor(Instant createdAt, UUID id) {
}
public record MessageCursor(Instant createdAt, UUID id) {
}
public String encodeIndex(int index) {
return Base64.getUrlEncoder()
.withoutPadding()
.encodeToString(
("i:" + index).getBytes(StandardCharsets.UTF_8)
);
}
public int decodeIndex(String cursor, int size) {
try {
String decoded = new String(
Base64.getUrlDecoder().decode(cursor),
StandardCharsets.UTF_8
);
if (!decoded.startsWith("i:")) {
throw new IllegalArgumentException();
}
int idx = Integer.parseInt(decoded.substring(2));
if (idx < 0 || idx > size) {
throw new IllegalArgumentException();
}
return idx;
} catch (IllegalArgumentException ex) {
throw BusinessException.invalid("Неверный cursor");
}
}
public String encodeChat(
UUID userId,
Instant createdAt,
UUID chatId
) {
String value = "chat:v1:"
+ userId + ":"
+ createdAt + ":"
+ chatId;
return Base64.getUrlEncoder()
.withoutPadding()
.encodeToString(
value.getBytes(StandardCharsets.UTF_8)
);
}
public ChatCursor decodeChat(String cursor, UUID userId) {
try {
String value = decodeBase64(cursor);
if (!value.startsWith("chat:v1:")) {
throw new IllegalArgumentException();
}
String content = value.substring("chat:v1:".length());
int firstSeparator = content.indexOf(':');
int lastSeparator = content.lastIndexOf(':');
if (firstSeparator < 0
|| lastSeparator <= firstSeparator) {
throw new IllegalArgumentException();
}
UUID cursorUserId = UUID.fromString(
content.substring(0, firstSeparator)
);
if (!cursorUserId.equals(userId)) {
throw new IllegalArgumentException();
}
Instant createdAt = Instant.parse(
content.substring(
firstSeparator + 1,
lastSeparator
)
);
UUID chatId = UUID.fromString(
content.substring(lastSeparator + 1)
);
return new ChatCursor(createdAt, chatId);
} catch (IllegalArgumentException | DateTimeParseException ex) {
throw BusinessException.invalid("Неверный cursor");
}
}
public String encodeMessage(
UUID chatId,
Instant createdAt,
UUID messageId
) {
String value = "message:v1:"
+ chatId + ":"
+ createdAt + ":"
+ messageId;
return Base64.getUrlEncoder()
.withoutPadding()
.encodeToString(
value.getBytes(StandardCharsets.UTF_8)
);
}
public MessageCursor decodeMessage(String cursor, UUID chatId) {
try {
String value = decodeBase64(cursor);
if (!value.startsWith("message:v1:")) {
throw new IllegalArgumentException();
}
String content = value.substring("message:v1:".length());
int firstSeparator = content.indexOf(':');
int lastSeparator = content.lastIndexOf(':');
if (firstSeparator < 0
|| lastSeparator <= firstSeparator) {
throw new IllegalArgumentException();
}
UUID cursorChatId = UUID.fromString(
content.substring(0, firstSeparator)
);
if (!cursorChatId.equals(chatId)) {
throw new IllegalArgumentException();
}
Instant createdAt = Instant.parse(
content.substring(
firstSeparator + 1,
lastSeparator
)
);
UUID messageId = UUID.fromString(
content.substring(lastSeparator + 1)
);
return new MessageCursor(createdAt, messageId);
} catch (IllegalArgumentException | DateTimeParseException ex) {
throw BusinessException.invalid("Неверный cursor");
}
}
private String decodeBase64(String cursor) {
if (cursor == null || cursor.isBlank()) {
throw new IllegalArgumentException();
}
return new String(
Base64.getUrlDecoder().decode(cursor),
StandardCharsets.UTF_8
);
}
}
@@ -0,0 +1,150 @@
package com.vnp.demo;
import org.slf4j.MDC;
import org.springframework.dao.DataAccessException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingRequestHeaderException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import org.springframework.web.server.ResponseStatusException;
import org.springframework.web.servlet.resource.NoResourceFoundException;
import com.vnp.demo.dto.ErrorResponse;
import jakarta.servlet.http.HttpServletRequest;
@RestControllerAdvice
public class GlobalExceptionHandler {
private ErrorResponse build(String code, String msg) {
return new ErrorResponse(
new ErrorResponse.ErrorBody(
code,
msg,
MDC.get("requestId")
)
);
}
@ExceptionHandler(BusinessException.class)
public ResponseEntity<ErrorResponse> handleBusiness(
BusinessException e,
HttpServletRequest request
) {
ResponseEntity.BodyBuilder builder =
ResponseEntity.status(e.getStatus());
if (e.getStatus() == HttpStatus.TOO_MANY_REQUESTS) {
builder.header("Retry-After", "1");
}
if (e.getStatus() == HttpStatus.UNAUTHORIZED) {
String path = request.getRequestURI();
String challenge = path.equals("/api/v1/auth/sessions")
? "Basic realm=\"messenger\", charset=\"UTF-8\""
: "Bearer realm=\"messenger\"";
builder.header("WWW-Authenticate", challenge);
}
return builder.body(
build(e.getCode(), e.getMessage())
);
}
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<ErrorResponse> handleValidation(
MethodArgumentNotValidException e
) {
String msg = e.getBindingResult()
.getFieldErrors()
.stream()
.findFirst()
.map(f -> f.getField() + ": " + f.getDefaultMessage())
.orElse("Ошибка валидации");
return ResponseEntity.badRequest()
.body(build("invalid_request", msg));
}
@ExceptionHandler({
HttpMessageNotReadableException.class,
MethodArgumentTypeMismatchException.class
})
public ResponseEntity<ErrorResponse> handleMalformed(Exception e) {
return ResponseEntity.badRequest()
.body(build(
"invalid_request",
"Неверный формат запроса"
));
}
@ExceptionHandler(NoResourceFoundException.class)
public ResponseEntity<ErrorResponse> handleNotFound(
NoResourceFoundException e
) {
return ResponseEntity.status(HttpStatus.NOT_FOUND)
.body(build(
"not_found",
"Ресурс не найден"
));
}
@ExceptionHandler(MissingRequestHeaderException.class)
public ResponseEntity<ErrorResponse> handleMissingHeader(
MissingRequestHeaderException e
) {
return ResponseEntity.badRequest()
.body(build(
"invalid_request",
"Отсутствует обязательный заголовок: "
+ e.getHeaderName()
));
}
@ExceptionHandler(DataAccessException.class)
public ResponseEntity<ErrorResponse> handleDataAccess(
DataAccessException e
) {
return ResponseEntity
.status(HttpStatus.SERVICE_UNAVAILABLE)
.body(build(
"unavailable",
"Сервис временно недоступен"
));
}
@ExceptionHandler(ResponseStatusException.class)
public ResponseEntity<ErrorResponse> handleStatus(
ResponseStatusException e
) {
int status = e.getStatusCode().value();
String code = status == 503
? "unavailable"
: "request_failed";
String message = status == 503
? "Сервис временно недоступен"
: "Запрос не может быть выполнен";
return ResponseEntity.status(status)
.body(build(code, message));
}
@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorResponse> handleGeneric(Exception e) {
return ResponseEntity
.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(build(
"internal_error",
"Внутренняя ошибка"
));
}
}
@@ -0,0 +1,13 @@
package com.vnp.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MessengerApplication {
public static void main(String[] args) {
SpringApplication.run(MessengerApplication.class, args);
}
}
@@ -0,0 +1,24 @@
package com.vnp.demo;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import java.util.Map;
@RestControllerAdvice
public class SessionStoreExceptionHandler {
@ExceptionHandler(SessionStoreUnavailableException.class)
public ResponseEntity<Map<String, String>> handleSessionStoreUnavailable(
SessionStoreUnavailableException ex
) {
return ResponseEntity
.status(HttpStatus.SERVICE_UNAVAILABLE)
.body(Map.of(
"error", "SERVICE_UNAVAILABLE",
"message", "Session storage is temporarily unavailable"
));
}
}
@@ -0,0 +1,8 @@
package com.vnp.demo;
public class SessionStoreUnavailableException extends RuntimeException {
public SessionStoreUnavailableException(Throwable cause) {
super("Session storage is temporarily unavailable", cause);
}
}
@@ -0,0 +1,22 @@
package main.java.com.vnp.demo.config;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.fasterxml.jackson.databind.cfg.CoercionAction;
import com.fasterxml.jackson.databind.cfg.CoercionInputShape;
import com.fasterxml.jackson.databind.type.LogicalType;
@Configuration
public class JacksonConfig {
@Bean
public Jackson2ObjectMapperBuilderCustomizer strictTextValues() {
return builder -> builder.postConfigurer(mapper ->
mapper.coercionConfigFor(LogicalType.Textual)
.setCoercion(CoercionInputShape.Integer, CoercionAction.Fail)
.setCoercion(CoercionInputShape.Float, CoercionAction.Fail)
.setCoercion(CoercionInputShape.Boolean, CoercionAction.Fail));
}
}
@@ -0,0 +1,15 @@
package com.vnp.demo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.argon2.Argon2PasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
public class PasswordConfig {
@Bean
public PasswordEncoder passwordEncoder() {
return Argon2PasswordEncoder.defaultsForSpringSecurity_v5_8();
}
}
@@ -0,0 +1,9 @@
package com.vnp.demo.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
@Configuration
@EnableScheduling
public class SchedulingConfig {
}
@@ -0,0 +1,75 @@
package com.vnp.demo.config;
import java.util.Map;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.vnp.demo.filter.BearerAuthenticationFilter;
import com.vnp.demo.service.AuthService;
import jakarta.servlet.http.HttpServletResponse;
@Configuration
public class SecurityConfig {
@Bean
public SecurityFilterChain securityFilterChain(
HttpSecurity http,
AuthService authService,
ObjectMapper objectMapper
) throws Exception {
return http
.csrf(csrf -> csrf.disable())
.httpBasic(basic -> basic.disable())
.formLogin(form -> form.disable())
.sessionManagement(session -> session
.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
)
.authorizeHttpRequests(auth -> auth
.requestMatchers(
"/health/live",
"/health/ready"
).permitAll()
.requestMatchers(
org.springframework.http.HttpMethod.POST,
"/api/v1/users",
"/api/v1/auth/sessions"
).permitAll()
.anyRequest().authenticated()
)
.exceptionHandling(ex -> ex
.authenticationEntryPoint((request, response, exception) -> {
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
response.setHeader(
HttpHeaders.WWW_AUTHENTICATE,
"Bearer realm=\"messenger\""
);
response.setContentType(MediaType.APPLICATION_JSON_VALUE);
response.setCharacterEncoding("UTF-8");
objectMapper.writeValue(
response.getWriter(),
Map.of("error", Map.of(
"code", "unauthorized",
"message", "Требуется авторизация",
"request_id", response.getHeader("X-Request-Id")
))
);
})
)
.addFilterBefore(
new BearerAuthenticationFilter(authService, objectMapper),
UsernamePasswordAuthenticationFilter.class
)
.build();
}
}
@@ -0,0 +1,25 @@
package com.vnp.demo.config;
import org.apache.coyote.http11.AbstractHttp11Protocol;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class UploadTimeoutConfig {
@Bean
public WebServerFactoryCustomizer<TomcatServletWebServerFactory>
uploadTimeoutCustomizer() {
return factory -> factory.addConnectorCustomizers(connector -> {
if (connector.getProtocolHandler()
instanceof AbstractHttp11Protocol<?> protocol) {
protocol.setDisableUploadTimeout(false);
protocol.setConnectionUploadTimeout(15_000);
}
});
}
}
@@ -0,0 +1,100 @@
package com.vnp.demo.controllers;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.UUID;
import org.springframework.http.ContentDisposition;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import com.vnp.demo.BusinessException;
import com.vnp.demo.dto.AttachmentResponse;
import com.vnp.demo.service.AttachmentService;
import jakarta.servlet.http.HttpServletRequest;
@RestController
@RequestMapping("/api/v1")
public class AttachmentController {
private final AttachmentService attachmentService;
public AttachmentController(
AttachmentService attachmentService
) {
this.attachmentService = attachmentService;
}
@PostMapping("/chats/{chat_id}/attachments")
@ResponseStatus(HttpStatus.CREATED)
public AttachmentResponse upload(
@AuthenticationPrincipal UUID userId,
@PathVariable("chat_id") UUID chatId,
@RequestParam(value = "filename", required = false)
String filename,
HttpServletRequest request
) {
try {
return attachmentService.upload(
userId,
chatId,
filename,
request.getContentType(),
request.getContentLengthLong(),
request.getInputStream()
);
} catch (IOException e) {
throw BusinessException.invalid(
"Не удалось прочитать тело запроса"
);
}
}
@GetMapping("/attachments/{id}")
public AttachmentResponse metadata(
@AuthenticationPrincipal UUID userId,
@PathVariable("id") UUID id
) {
return attachmentService.getMetadata(userId, id);
}
@GetMapping("/attachments/{id}/content")
public ResponseEntity<byte[]> content(
@AuthenticationPrincipal UUID userId,
@PathVariable("id") UUID id,
@RequestParam(defaultValue = "original")
String variant
) {
AttachmentService.Download download =
attachmentService.download(userId, id, variant);
String disposition = ContentDisposition.attachment()
.filename(
download.filename(),
StandardCharsets.UTF_8
)
.build()
.toString();
return ResponseEntity.ok()
.contentType(
MediaType.parseMediaType(download.contentType())
)
.contentLength(download.bytes().length)
.header(HttpHeaders.CONTENT_DISPOSITION, disposition)
.header(HttpHeaders.CACHE_CONTROL, "private, no-store")
.header("X-Content-Type-Options", "nosniff")
.body(download.bytes());
}
}
@@ -0,0 +1,93 @@
package com.vnp.demo.controllers;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import com.vnp.demo.BusinessException;
import com.vnp.demo.dto.SessionResponse;
import com.vnp.demo.service.AuthService;
import jakarta.servlet.http.HttpServletRequest;
@RestController
@RequestMapping("/api/v1/auth/sessions")
public class AuthController {
private final AuthService authService;
public AuthController(AuthService authService) {
this.authService = authService;
}
@PostMapping
@ResponseStatus(HttpStatus.CREATED)
public SessionResponse login(
@RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false)
String authorization,
HttpServletRequest request
) throws IOException {
if (request.getInputStream().read() != -1) {
throw BusinessException.invalid("Тело запроса создания сессии должно быть пустым");
}
if (authorization == null
|| !authorization.startsWith("Basic ")) {
throw BusinessException.unauthorized();
}
String encoded = authorization.substring(6).trim();
String credentials;
try {
byte[] decoded = Base64.getDecoder().decode(encoded);
credentials = StandardCharsets.UTF_8
.newDecoder()
.decode(ByteBuffer.wrap(decoded))
.toString();
} catch (IllegalArgumentException | CharacterCodingException ex) {
throw BusinessException.unauthorized();
}
int separator = credentials.indexOf(':');
if (separator < 0) {
throw BusinessException.unauthorized();
}
String username = credentials.substring(0, separator);
String password = credentials.substring(separator + 1);
if (!username.matches("[a-z0-9_]{3,32}")) {
throw BusinessException.unauthorized();
}
return authService.login(username, password);
}
@DeleteMapping("/current")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void logout(
@RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false)
String authorization
) {
if (authorization == null
|| !authorization.startsWith("Bearer ")) {
throw BusinessException.unauthorized();
}
authService.logout(authorization.substring(7).trim());
}
}
@@ -0,0 +1,58 @@
package com.vnp.demo.controllers;
import java.util.UUID;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import com.vnp.demo.dto.ChatCreateRequest;
import com.vnp.demo.dto.ChatPageResponse;
import com.vnp.demo.dto.ChatResponse;
import com.vnp.demo.service.ChatService;
import jakarta.validation.Valid;
@RestController
@RequestMapping("/api/v1/chats")
public class ChatController {
private final ChatService chatService;
public ChatController(ChatService chatService) {
this.chatService = chatService;
}
@PostMapping
@ResponseStatus(HttpStatus.CREATED)
public ChatResponse create(
@AuthenticationPrincipal UUID userId,
@Valid @RequestBody ChatCreateRequest request
) {
return chatService.create(userId, request);
}
@GetMapping
public ChatPageResponse list(
@AuthenticationPrincipal UUID userId,
@RequestParam(defaultValue = "50") int limit,
@RequestParam(required = false) String cursor
) {
return chatService.list(userId, limit, cursor);
}
@GetMapping("/{chat_id}")
public ChatResponse get(
@AuthenticationPrincipal UUID userId,
@PathVariable("chat_id") UUID chatId
) {
return chatService.get(userId, chatId);
}
}
@@ -0,0 +1,49 @@
package com.vnp.demo.controllers;
import org.springframework.boot.availability.ApplicationAvailability;
import org.springframework.boot.availability.ReadinessState;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.vnp.demo.service.S3StorageService;
import com.vnp.demo.BusinessException;
import com.vnp.demo.dto.HealthResponse;
@RestController
@RequestMapping("/health")
public class HealthController {
private final JdbcTemplate jdbc;
private final StringRedisTemplate redis;
private final ApplicationAvailability availability;
private final S3StorageService storage;
public HealthController(
JdbcTemplate jdbc,
StringRedisTemplate redis,
ApplicationAvailability availability,
S3StorageService storage
) {
this.jdbc = jdbc;
this.redis = redis;
this.availability = availability;
this.storage = storage;
}
@GetMapping("/live")
public HealthResponse live() { return HealthResponse.ok(); }
@GetMapping("/ready")
public HealthResponse ready() {
try {
if (availability.getReadinessState() != ReadinessState.ACCEPTING_TRAFFIC) throw new IllegalStateException();
if (!Integer.valueOf(1).equals(jdbc.queryForObject("SELECT 1", Integer.class))) throw new IllegalStateException();
String pong = redis.execute((org.springframework.data.redis.core.RedisCallback<String>) c -> c.ping());
if (!"PONG".equals(pong)) throw new IllegalStateException();
storage.checkReady();
return HealthResponse.ok();
} catch (Exception ex) {
throw new BusinessException("service_unavailable", "Сервис не готов", HttpStatus.SERVICE_UNAVAILABLE);
}
}
}
@@ -0,0 +1,53 @@
package com.vnp.demo.controllers;
import java.util.UUID;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import com.vnp.demo.dto.MessageCreateRequest;
import com.vnp.demo.dto.MessagePageResponse;
import com.vnp.demo.dto.MessageResponse;
import com.vnp.demo.service.MessageService;
import jakarta.validation.Valid;
@RestController
@RequestMapping("/api/v1/chats/{chat_id}/messages")
public class MessageController {
private final MessageService messageService;
public MessageController(MessageService messageService) {
this.messageService = messageService;
}
@PostMapping
@ResponseStatus(HttpStatus.CREATED)
public MessageResponse create(
@AuthenticationPrincipal UUID userId,
@PathVariable("chat_id") UUID chatId,
@org.springframework.web.bind.annotation.RequestHeader("Idempotency-Key") String key,
@Valid @RequestBody MessageCreateRequest request
) {
return messageService.create(userId, chatId, request, key);
}
@GetMapping
public MessagePageResponse list(
@AuthenticationPrincipal UUID userId,
@PathVariable("chat_id") UUID chatId,
@RequestParam(defaultValue = "50") int limit,
@RequestParam(required = false) String cursor
) {
return messageService.list(userId, chatId, limit, cursor);
}
}
@@ -0,0 +1,44 @@
package com.vnp.demo.controllers;
import java.util.UUID;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import com.vnp.demo.dto.UserCreateRequest;
import com.vnp.demo.dto.UserResponse;
import com.vnp.demo.service.UserService;
import jakarta.validation.Valid;
@RestController
@RequestMapping("/api/v1/users")
public class UserController {
private final UserService userService;
public UserController(UserService userService) {
this.userService = userService;
}
@PostMapping
@ResponseStatus(HttpStatus.CREATED)
public UserResponse register(
@Valid @RequestBody UserCreateRequest request
) {
return userService.register(request);
}
@GetMapping("/me")
public UserResponse getCurrent(
@AuthenticationPrincipal UUID userId
) {
return userService.getCurrent(userId);
}
}
@@ -0,0 +1,56 @@
package com.vnp.demo.dto;
import java.time.Instant;
import java.util.List;
import java.util.UUID;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.vnp.demo.models.Attachment;
public record AttachmentResponse(
UUID id,
@JsonProperty("chat_id")
UUID chatId,
@JsonProperty("owner_id")
UUID ownerId,
String filename,
@JsonProperty("content_type")
String contentType,
@JsonProperty("size_bytes")
long sizeBytes,
String sha256,
String status,
List<Object> variants,
@JsonProperty("error_code")
String errorCode,
@JsonProperty("created_at")
Instant createdAt,
@JsonProperty("updated_at")
Instant updatedAt
) {
public static AttachmentResponse from(Attachment attachment) {
return new AttachmentResponse(
attachment.id(),
attachment.chatId(),
attachment.ownerId(),
attachment.filename(),
attachment.contentType(),
attachment.sizeBytes(),
attachment.sha256(),
attachment.status(),
List.of(),
null,
attachment.createdAt(),
attachment.updatedAt()
);
}
}
@@ -0,0 +1,23 @@
package com.vnp.demo.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import org.hibernate.validator.constraints.UniqueElements;
import java.util.List;
import java.util.UUID;
public record ChatCreateRequest(
@NotBlank
@Size(max = 100)
String title,
@NotEmpty
@Size(max = 100)
@UniqueElements
@JsonProperty("member_ids")
List<@NotNull UUID> memberIds
) {}
@@ -0,0 +1,10 @@
package com.vnp.demo.dto;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonProperty;
public record ChatPageResponse(
List<ChatResponse> items,
@JsonProperty("next_cursor") String nextCursor
) {}
@@ -0,0 +1,16 @@
package com.vnp.demo.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.time.Instant;
import java.util.List;
import java.util.UUID;
public record ChatResponse(
UUID id,
String title,
@JsonProperty("member_ids")
List<UUID> memberIds,
@JsonProperty("created_at")
Instant createdAt
) {}
@@ -0,0 +1,14 @@
package com.vnp.demo.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
public record ErrorResponse(ErrorBody error) {
public record ErrorBody(
String code,
String message,
@JsonProperty("request_id")
String requestId
) {}
}
@@ -0,0 +1,6 @@
package com.vnp.demo.dto;
public record HealthResponse(String status) {
public static HealthResponse ok()
{ return new HealthResponse("ok"); }
}
@@ -0,0 +1,53 @@
package com.vnp.demo.dto;
import java.util.List;
import java.util.UUID;
import com.fasterxml.jackson.annotation.JsonSetter;
import com.fasterxml.jackson.annotation.Nulls;
public class MessageCreateRequest {
private String text;
private List<UUID> attachmentIds = List.of();
public MessageCreateRequest() {
}
public MessageCreateRequest(String text) {
this.text = text;
}
public MessageCreateRequest(
String text,
List<UUID> attachmentIds
) {
this.text = text;
this.attachmentIds = attachmentIds;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
public String text() {
return text;
}
public List<UUID> attachmentIds() {
return attachmentIds;
}
@JsonSetter(
value = "attachment_ids",
nulls = Nulls.FAIL,
contentNulls = Nulls.FAIL
)
public void setAttachmentIds(List<UUID> attachmentIds) {
this.attachmentIds = attachmentIds;
}
}
@@ -0,0 +1,10 @@
package com.vnp.demo.dto;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonProperty;
public record MessagePageResponse(
List<MessageResponse> items,
@JsonProperty("next_cursor") String nextCursor
) {}
@@ -0,0 +1,26 @@
package com.vnp.demo.dto;
import java.time.Instant;
import java.util.List;
import java.util.UUID;
import com.fasterxml.jackson.annotation.JsonProperty;
public record MessageResponse(
UUID id,
@JsonProperty("chat_id")
UUID chatId,
@JsonProperty("sender_id")
UUID senderId,
String text,
@JsonProperty("created_at")
Instant createdAt,
@JsonProperty("attachment_ids")
List<UUID> attachmentIds
) {
}
@@ -0,0 +1,13 @@
package com.vnp.demo.dto;
import java.time.Instant;
import com.fasterxml.jackson.annotation.JsonProperty;
public record SessionResponse(
String token,
@JsonProperty("token_type") String tokenType,
@JsonProperty("expires_at") Instant expiresAt,
UserResponse user
) {
}
@@ -0,0 +1,18 @@
package com.vnp.demo.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.*;
public record UserCreateRequest(
@NotBlank
@Pattern(regexp = "^[a-z0-9_]{3,32}$")
String username,
@JsonProperty("display_name")
@NotBlank
String displayName,
@NotNull
String password
) {}
@@ -0,0 +1,21 @@
package com.vnp.demo.dto;
import java.time.Instant;
import java.util.UUID;
import com.fasterxml.jackson.annotation.JsonProperty;
public record UserResponse(
UUID id,
String username,
@JsonProperty("display_name")
String displayName,
@JsonProperty("created_at")
Instant createdAt
) {
}
@@ -0,0 +1,148 @@
package com.vnp.demo.filter;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import org.springframework.dao.DataAccessException;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.transaction.CannotCreateTransactionException;
import org.springframework.web.filter.OncePerRequestFilter;
import org.springframework.web.server.ResponseStatusException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.vnp.demo.BusinessException;
import com.vnp.demo.SessionStoreUnavailableException;
import com.vnp.demo.models.User;
import com.vnp.demo.service.AuthService;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
public class BearerAuthenticationFilter extends OncePerRequestFilter {
private final AuthService authService;
private final ObjectMapper objectMapper;
public BearerAuthenticationFilter(
AuthService authService,
ObjectMapper objectMapper
) {
this.authService = authService;
this.objectMapper = objectMapper;
}
@Override
protected void doFilterInternal(
HttpServletRequest request,
HttpServletResponse response,
FilterChain chain
) throws ServletException, IOException {
String authorization = request.getHeader(HttpHeaders.AUTHORIZATION);
if (authorization == null || !authorization.startsWith("Bearer ")) {
chain.doFilter(request, response);
return;
}
String token = authorization.substring(7).trim();
User user;
try {
user = authService.authenticate(token);
} catch (BusinessException ex) {
SecurityContextHolder.clearContext();
response.setHeader(
HttpHeaders.WWW_AUTHENTICATE,
"Bearer realm=\"messenger\""
);
writeError(
response,
HttpServletResponse.SC_UNAUTHORIZED,
"unauthorized",
"Недействительный токен"
);
return;
} catch (SessionStoreUnavailableException | DataAccessException | CannotCreateTransactionException ex) {
SecurityContextHolder.clearContext();
writeError(
response,
HttpServletResponse.SC_SERVICE_UNAVAILABLE,
"unavailable",
"Сервис временно недоступен"
);
return;
} catch (ResponseStatusException ex) {
SecurityContextHolder.clearContext();
if (ex.getStatusCode().value() == 503) {
writeError(
response,
HttpServletResponse.SC_SERVICE_UNAVAILABLE,
"unavailable",
"Сервис временно недоступен"
);
return;
}
throw ex;
}
try {
UsernamePasswordAuthenticationToken authentication =
new UsernamePasswordAuthenticationToken(
user.getId(),
null,
List.of()
);
SecurityContextHolder.getContext()
.setAuthentication(authentication);
chain.doFilter(request, response);
} finally {
SecurityContextHolder.clearContext();
}
}
private void writeError(
HttpServletResponse response,
int status,
String code,
String message
) throws IOException {
response.setStatus(status);
response.setContentType(MediaType.APPLICATION_JSON_VALUE);
response.setCharacterEncoding("UTF-8");
String requestId = response.getHeader("X-Request-Id");
objectMapper.writeValue(
response.getWriter(),
Map.of(
"error", Map.of(
"code", code,
"message", message,
"request_id",
requestId != null ? requestId : ""
)
)
);
}
}
@@ -0,0 +1,77 @@
package com.vnp.demo.filter;
import java.io.IOException;
import java.util.UUID;
import org.slf4j.MDC;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class RequestIdFilter extends OncePerRequestFilter {
private final String instanceId = System.getenv().getOrDefault("HOSTNAME", UUID.randomUUID().toString());
public static final String HEADER = "X-Request-Id";
public static final String MDC_KEY = "requestId";
private static final int MAX_REQUEST_ID_LENGTH = 128;
@Override
protected void doFilterInternal(
HttpServletRequest request,
HttpServletResponse response,
FilterChain chain
) throws ServletException, IOException {
String requestId = request.getHeader(HEADER);
if (requestId == null
|| requestId.isBlank()
|| requestId.length() > MAX_REQUEST_ID_LENGTH
|| !isValidRequestId(requestId)) {
requestId = UUID.randomUUID()
.toString()
.replace("-", "");
}
response.setHeader(HEADER, requestId);
response.setHeader("X-Instance-Id", instanceId);
request.setAttribute(MDC_KEY, requestId);
MDC.put(MDC_KEY, requestId);
try {
chain.doFilter(request, response);
} finally {
MDC.remove(MDC_KEY);
}
}
private boolean isValidRequestId(String requestId) {
for (int i = 0; i < requestId.length(); i++) {
char c = requestId.charAt(i);
if (!(
(c >= 'a' && c <= 'z')
|| (c >= 'A' && c <= 'Z')
|| (c >= '0' && c <= '9')
|| c == '-'
|| c == '_'
)) {
return false;
}
}
return true;
}
}
@@ -0,0 +1,19 @@
package com.vnp.demo.models;
import java.time.Instant;
import java.util.UUID;
public record Attachment(
UUID id,
UUID chatId,
UUID ownerId,
String filename,
String contentType,
long sizeBytes,
String sha256,
String objectKey,
String status,
Instant createdAt,
Instant updatedAt
) {
}
@@ -0,0 +1,46 @@
package com.vnp.demo.models;
import java.time.Instant;
import java.util.UUID;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
@Entity
@Table(name = "chats")
public class Chat {
@Id
private UUID id = UUID.randomUUID();
@Column(nullable = false, length = 400)
private String title;
@Column(name = "created_at", nullable = false)
private Instant createdAt = Instant.now();
protected Chat() {
}
public Chat(String title) {
this.title = title;
}
public UUID getId() {
return id;
}
public String getTitle() {
return title;
}
public Instant getCreatedAt() {
return createdAt;
}
public void setTitle(String title) {
this.title = title;
}
}
@@ -0,0 +1,45 @@
package com.vnp.demo.models;
import jakarta.persistence.*;
@Entity
@Table(name = "chat_members")
public class ChatMember {
@EmbeddedId
private ChatMemberId id;
@MapsId("chatId")
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "chat_id", nullable = false)
private Chat chat;
@MapsId("userId")
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "user_id", nullable = false)
private User user;
protected ChatMember() {
}
public ChatMember(Chat chat, User user) {
this.chat = chat;
this.user = user;
this.id = new ChatMemberId(
chat.getId(),
user.getId()
);
}
public ChatMemberId getId() {
return id;
}
public Chat getChat() {
return chat;
}
public User getUser() {
return user;
}
}
@@ -0,0 +1,53 @@
package com.vnp.demo.models;
import java.io.Serializable;
import java.util.Objects;
import java.util.UUID;
import jakarta.persistence.Column;
import jakarta.persistence.Embeddable;
@Embeddable
public class ChatMemberId implements Serializable {
@Column(name = "chat_id", nullable = false)
private UUID chatId;
@Column(name = "user_id", nullable = false)
private UUID userId;
protected ChatMemberId() {
}
public ChatMemberId(UUID chatId, UUID userId) {
this.chatId = chatId;
this.userId = userId;
}
public UUID getChatId() {
return chatId;
}
public UUID getUserId() {
return userId;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof ChatMemberId other)) {
return false;
}
return Objects.equals(chatId, other.chatId)
&& Objects.equals(userId, other.userId);
}
@Override
public int hashCode() {
return Objects.hash(chatId, userId);
}
}
@@ -0,0 +1,91 @@
package com.vnp.demo.models;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import jakarta.persistence.CollectionTable;
import jakarta.persistence.Column;
import jakarta.persistence.ElementCollection;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OrderColumn;
import jakarta.persistence.Table;
@Entity
@Table(name = "messages")
public class Message {
@Id
private UUID id = UUID.randomUUID();
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "chat_id", nullable = false)
private Chat chat;
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "sender_id", nullable = false)
private User sender;
@Column(name = "text", nullable = false, columnDefinition = "text")
private String text;
@Column(name = "created_at", nullable = false)
private Instant createdAt = Instant.now();
@ElementCollection(fetch = FetchType.LAZY)
@CollectionTable(
name = "message_attachments",
joinColumns = @JoinColumn(name = "message_id")
)
@Column(name = "attachment_id", nullable = false)
@OrderColumn(name = "position")
private List<UUID> attachmentIds = new ArrayList<>();
protected Message() {
}
public Message(Chat chat, User sender, String text) {
this(chat, sender, text, List.of());
}
public Message(
Chat chat,
User sender,
String text,
List<UUID> attachmentIds
) {
this.chat = chat;
this.sender = sender;
this.text = text;
this.attachmentIds = new ArrayList<>(attachmentIds);
}
public UUID getId() {
return id;
}
public Chat getChat() {
return chat;
}
public User getSender() {
return sender;
}
public String getText() {
return text;
}
public Instant getCreatedAt() {
return createdAt;
}
public List<UUID> getAttachmentIds() {
return attachmentIds;
}
}
@@ -0,0 +1,90 @@
package com.vnp.demo.models;
import java.sql.Types;
import java.time.Instant;
import java.util.UUID;
import org.hibernate.annotations.JdbcTypeCode;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
@Entity
@Table(name = "sessions")
public class Session {
@Id
private UUID id = UUID.randomUUID();
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "user_id", nullable = false)
private User user;
@JdbcTypeCode(Types.CHAR)
@Column(
name = "token_hash",
nullable = false,
unique = true,
length = 64,
columnDefinition = "CHAR(64)"
)
private String tokenHash;
@Column(name = "expires_at", nullable = false)
private Instant expiresAt;
@Column(name = "revoked_at")
private Instant revokedAt;
@Column(name = "created_at", nullable = false)
private Instant createdAt = Instant.now();
protected Session() {
}
public Session(User user, String tokenHash, Instant expiresAt) {
this.user = user;
this.tokenHash = tokenHash;
this.expiresAt = expiresAt;
}
public UUID getId() {
return id;
}
public User getUser() {
return user;
}
public String getTokenHash() {
return tokenHash;
}
public Instant getExpiresAt() {
return expiresAt;
}
public Instant getRevokedAt() {
return revokedAt;
}
public Instant getCreatedAt() {
return createdAt;
}
public boolean isValid() {
return revokedAt == null
&& expiresAt.isAfter(Instant.now());
}
public void revoke() {
if (revokedAt == null) {
revokedAt = Instant.now();
}
}
}
@@ -0,0 +1,63 @@
package com.vnp.demo.models;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.UUID;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
@Entity
@Table(name = "users")
public class User {
@Id
private UUID id = UUID.randomUUID();
@Column(nullable = false, unique = true, length = 32)
private String username;
@Column(name = "display_name", nullable = false)
private String displayName;
@Column(name = "password_hash", nullable = false)
private String passwordHash;
@Column(name = "created_at", nullable = false)
private Instant createdAt = Instant.now().truncatedTo(ChronoUnit.MICROS);
protected User() {
}
public User(String username, String displayName, String passwordHash) {
this.username = username;
this.displayName = displayName;
this.passwordHash = passwordHash;
}
public UUID getId() {
return id;
}
public String getUsername() {
return username;
}
public String getDisplayName() {
return displayName;
}
public String getPasswordHash() {
return passwordHash;
}
public Instant getCreatedAt() {
return createdAt;
}
public void setDisplayName(String displayName) {
this.displayName = displayName;
}
}
@@ -0,0 +1,122 @@
package com.vnp.demo.repositories;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.Optional;
import java.util.UUID;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import com.vnp.demo.models.Attachment;
@Repository
public class AttachmentRepository {
private final JdbcTemplate jdbc;
public AttachmentRepository(JdbcTemplate jdbc) {
this.jdbc = jdbc;
}
public void save(Attachment attachment) {
jdbc.update(
"""
INSERT INTO attachments (
id,
chat_id,
owner_id,
filename,
content_type,
size_bytes,
sha256,
object_key,
status,
created_at,
updated_at
)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
""",
attachment.id(),
attachment.chatId(),
attachment.ownerId(),
attachment.filename(),
attachment.contentType(),
attachment.sizeBytes(),
attachment.sha256(),
attachment.objectKey(),
attachment.status(),
Timestamp.from(attachment.createdAt()),
Timestamp.from(attachment.updatedAt())
);
}
public Optional<Attachment> findById(UUID id) {
return jdbc.query(
"SELECT * FROM attachments WHERE id = ?",
this::mapRow,
id
).stream().findFirst();
}
private Attachment mapRow(ResultSet rs, int rowNum)
throws SQLException {
return new Attachment(
rs.getObject("id", UUID.class),
rs.getObject("chat_id", UUID.class),
rs.getObject("owner_id", UUID.class),
rs.getString("filename"),
rs.getString("content_type"),
rs.getLong("size_bytes"),
rs.getString("sha256"),
rs.getString("object_key"),
rs.getString("status"),
rs.getTimestamp("created_at").toInstant(),
rs.getTimestamp("updated_at").toInstant()
);
}
public boolean existsByObjectKey(String objectKey) {
Boolean exists = jdbc.queryForObject(
"""
SELECT EXISTS (
SELECT 1
FROM attachments
WHERE object_key = ?
)
""",
Boolean.class,
objectKey
);
return Boolean.TRUE.equals(exists);
}
public void lockObject(String objectKey) {
jdbc.query(
"""
SELECT pg_advisory_xact_lock(
hashtextextended(?, 0)
)
""",
(rs, rowNum) -> Boolean.TRUE,
"attachment-object:" + objectKey
);
}
public boolean tryLockObject(String objectKey) {
Boolean acquired = jdbc.queryForObject(
"""
SELECT pg_try_advisory_xact_lock(
hashtextextended(?, 0)
)
""",
Boolean.class,
"attachment-object:" + objectKey
);
return Boolean.TRUE.equals(acquired);
}
}
@@ -0,0 +1,19 @@
package com.vnp.demo.repositories;
import java.util.List;
import java.util.UUID;
import org.springframework.data.jpa.repository.JpaRepository;
import com.vnp.demo.models.ChatMember;
import com.vnp.demo.models.ChatMemberId;
public interface ChatMemberRepository
extends JpaRepository<ChatMember, ChatMemberId> {
boolean existsByIdChatIdAndIdUserId(UUID chatId, UUID userId);
List<ChatMember> findByIdChatId(UUID chatId);
boolean existsByChat_IdAndUser_Id(UUID chatId, UUID userId);
}
@@ -0,0 +1,56 @@
package com.vnp.demo.repositories;
import java.time.Instant;
import java.util.List;
import java.util.UUID;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import com.vnp.demo.models.Chat;
public interface ChatRepository extends JpaRepository<Chat, UUID> {
@Query("""
SELECT c
FROM Chat c
WHERE EXISTS (
SELECT 1
FROM ChatMember cm
WHERE cm.chat.id = c.id
AND cm.user.id = :userId
)
ORDER BY c.createdAt ASC, c.id ASC
""")
List<Chat> findFirstPage(
@Param("userId") UUID userId,
Pageable pageable
);
@Query("""
SELECT c
FROM Chat c
WHERE EXISTS (
SELECT 1
FROM ChatMember cm
WHERE cm.chat.id = c.id
AND cm.user.id = :userId
)
AND (
c.createdAt > :cursorTime
OR (
c.createdAt = :cursorTime
AND c.id > :cursorId
)
)
ORDER BY c.createdAt ASC, c.id ASC
""")
List<Chat> findNextPage(
@Param("userId") UUID userId,
@Param("cursorTime") Instant cursorTime,
@Param("cursorId") UUID cursorId,
Pageable pageable
);
}
@@ -0,0 +1,40 @@
package com.vnp.demo.repositories;
import java.time.Instant;
import java.util.List;
import java.util.UUID;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import com.vnp.demo.models.Message;
public interface MessageRepository extends JpaRepository<Message, UUID> {
@Query(value = """
SELECT m.*
FROM messages m
WHERE m.chat_id = :chatId
ORDER BY m.created_at ASC, m.id ASC
""", nativeQuery = true)
List<Message> findFirstPage(
@Param("chatId") UUID chatId,
Pageable pageable
);
@Query(value = """
SELECT m.*
FROM messages m
WHERE m.chat_id = :chatId
AND (m.created_at, m.id) > (:cursorTime, :cursorId)
ORDER BY m.created_at ASC, m.id ASC
""", nativeQuery = true)
List<Message> findNextPage(
@Param("chatId") UUID chatId,
@Param("cursorTime") Instant cursorTime,
@Param("cursorId") UUID cursorId,
Pageable pageable
);
}
@@ -0,0 +1,12 @@
package com.vnp.demo.repositories;
import com.vnp.demo.models.Session;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;
import java.util.UUID;
public interface SessionRepository extends JpaRepository<Session, UUID> {
Optional<Session> findByTokenHash(String tokenHash);
}
@@ -0,0 +1,14 @@
package com.vnp.demo.repositories;
import com.vnp.demo.models.User;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;
import java.util.UUID;
public interface UserRepository extends JpaRepository<User, UUID> {
Optional<User> findByUsername(String username);
boolean existsByUsername(String username);
}
@@ -0,0 +1,119 @@
package com.vnp.demo.service;
import java.time.Instant;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import com.vnp.demo.service.AttachmentPersistenceService.CleanupResult;
import io.minio.Result;
import io.minio.messages.Item;
@Component
@ConditionalOnProperty(
name = "app.cleanup.enabled",
havingValue = "true",
matchIfMissing = true
)
public class AttachmentCleanupJob {
private static final Logger log =
LoggerFactory.getLogger(AttachmentCleanupJob.class);
private final S3StorageService storage;
private final AttachmentPersistenceService persistence;
private final long graceSeconds;
public AttachmentCleanupJob(
S3StorageService storage,
AttachmentPersistenceService persistence,
@Value("${app.cleanup.grace-seconds:3600}")
long graceSeconds
) {
if (graceSeconds < 60) {
throw new IllegalArgumentException(
"Grace period должен быть не меньше 60 секунд"
);
}
this.storage = storage;
this.persistence = persistence;
this.graceSeconds = graceSeconds;
}
@Scheduled(
initialDelayString =
"${app.cleanup.initial-delay-ms:60000}",
fixedDelayString =
"${app.cleanup.interval-ms:300000}"
)
public void cleanup() {
Instant cutoff = Instant.now()
.minusSeconds(graceSeconds);
long scanned = 0;
long candidates = 0;
long deleted = 0;
try {
for (Result<Item> result : storage.listOriginals()) {
Item item = result.get();
if (item.isDir()) {
continue;
}
scanned++;
Instant lastModified = item.lastModified()
.toInstant();
if (!lastModified.isBefore(cutoff)) {
continue;
}
candidates++;
CleanupResult outcome =
persistence.removeIfOrphan(
item.objectName(),
cutoff
);
if (outcome == CleanupResult.DELETED) {
deleted++;
log.info(
"Attachment cleanup removed orphan: {}",
item.objectName()
);
}
}
log.info(
"Attachment cleanup completed: "
+ "scanned={}, candidates={}, deleted={}",
scanned,
candidates,
deleted
);
} catch (Exception e) {
// Прерываем текущий проход при ошибке БД или S3.
// Следующий запуск повторит проверку.
// Не выводим credentials или содержимое ответа S3.
log.warn(
"Attachment cleanup interrupted: "
+ "scanned={}, candidates={}, deleted={}, errorType={}",
scanned,
candidates,
deleted,
e.getClass().getSimpleName()
);
}
}
}
@@ -0,0 +1,94 @@
package com.vnp.demo.service;
import java.nio.file.Path;
import java.time.Instant;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;
import com.vnp.demo.models.Attachment;
import com.vnp.demo.repositories.AttachmentRepository;
@Service
public class AttachmentPersistenceService {
private final AttachmentRepository attachmentRepository;
private final S3StorageService storage;
public AttachmentPersistenceService(
AttachmentRepository attachmentRepository,
S3StorageService storage
) {
this.attachmentRepository = attachmentRepository;
this.storage = storage;
}
@Transactional(
isolation = Isolation.READ_COMMITTED,
timeout = 60
)
public void save(
Attachment attachment,
Path temporaryFile
) {
attachmentRepository.lockObject(
attachment.objectKey()
);
storage.put(
attachment.objectKey(),
temporaryFile,
attachment.sizeBytes(),
attachment.contentType()
);
attachmentRepository.save(attachment);
}
@Transactional(
isolation = Isolation.READ_COMMITTED,
timeout = 30
)
public CleanupResult removeIfOrphan(
String objectKey,
Instant cutoff
) {
if (!objectKey.startsWith("originals/")) {
return CleanupResult.SKIPPED;
}
if (!attachmentRepository.tryLockObject(objectKey)) {
return CleanupResult.BUSY;
}
if (attachmentRepository.existsByObjectKey(objectKey)) {
return CleanupResult.REFERENCED;
}
Instant lastModified = storage.lastModifiedOrNull(
objectKey
);
if (lastModified == null) {
return CleanupResult.MISSING;
}
if (!lastModified.isBefore(cutoff)) {
return CleanupResult.RECENT;
}
storage.remove(objectKey);
return CleanupResult.DELETED;
}
public enum CleanupResult {
DELETED,
REFERENCED,
RECENT,
BUSY,
MISSING,
SKIPPED
}
}
@@ -0,0 +1,163 @@
package com.vnp.demo.service;
import java.io.InputStream;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.UUID;
import org.springframework.stereotype.Service;
import com.vnp.demo.BusinessException;
import com.vnp.demo.dto.AttachmentResponse;
import com.vnp.demo.models.Attachment;
import com.vnp.demo.repositories.AttachmentRepository;
import com.vnp.demo.repositories.ChatMemberRepository;
import com.vnp.demo.validation.ImageValidator;
import com.vnp.demo.validation.ImageValidator.ValidatedImage;
@Service
public class AttachmentService {
private final AttachmentRepository attachmentRepository;
private final ChatMemberRepository chatMemberRepository;
private final ImageValidator imageValidator;
private final S3StorageService storage;
private final UploadLimiter uploadLimiter;
private final AttachmentPersistenceService persistence;
public AttachmentService(
AttachmentRepository attachmentRepository,
ChatMemberRepository chatMemberRepository,
ImageValidator imageValidator,
S3StorageService storage,
UploadLimiter uploadLimiter,
AttachmentPersistenceService persistence
) {
this.attachmentRepository = attachmentRepository;
this.chatMemberRepository = chatMemberRepository;
this.imageValidator = imageValidator;
this.storage = storage;
this.uploadLimiter = uploadLimiter;
this.persistence = persistence;
}
public AttachmentResponse upload(
UUID userId,
UUID chatId,
String filename,
String contentType,
long contentLength,
InputStream input
) {
checkChatAccess(userId, chatId);
imageValidator.validateFilename(filename);
try (UploadLimiter.Permit permit = uploadLimiter.acquire();
ValidatedImage image = imageValidator.validate(
input,
contentLength,
contentType
)) {
UUID attachmentId = UUID.randomUUID();
String objectKey = "originals/"
+ chatId
+ "/"
+ attachmentId;
Instant now = Instant.now()
.truncatedTo(ChronoUnit.MICROS);
Attachment attachment = new Attachment(
attachmentId,
chatId,
userId,
filename,
image.contentType(),
image.sizeBytes(),
image.sha256(),
objectKey,
"ready",
now,
now
);
persistence.save(attachment, image.path());
return AttachmentResponse.from(attachment);
}
}
public AttachmentResponse getMetadata(
UUID userId,
UUID attachmentId
) {
return AttachmentResponse.from(
getAccessibleAttachment(userId, attachmentId)
);
}
public Download download(
UUID userId,
UUID attachmentId,
String variant
) {
Attachment attachment = getAccessibleAttachment(
userId,
attachmentId
);
if (!"ready".equals(attachment.status())) {
throw BusinessException.conflict(
"Вложение ещё не готово"
);
}
if (!"original".equals(variant)) {
throw BusinessException.notFound();
}
byte[] bytes = storage.get(
attachment.objectKey(),
attachment.sizeBytes(),
attachment.sha256()
);
return new Download(
attachment.filename(),
attachment.contentType(),
bytes
);
}
private Attachment getAccessibleAttachment(
UUID userId,
UUID attachmentId
) {
Attachment attachment = attachmentRepository
.findById(attachmentId)
.orElseThrow(BusinessException::notFound);
checkChatAccess(userId, attachment.chatId());
return attachment;
}
private void checkChatAccess(UUID userId, UUID chatId) {
boolean member = chatMemberRepository
.existsByIdChatIdAndIdUserId(chatId, userId);
if (!member) {
throw BusinessException.notFound();
}
}
public record Download(
String filename,
String contentType,
byte[] bytes
) {
}
}
@@ -0,0 +1,143 @@
package com.vnp.demo.service;
import com.vnp.demo.BusinessException;
import com.vnp.demo.dto.SessionResponse;
import com.vnp.demo.dto.UserResponse;
import com.vnp.demo.models.Session;
import com.vnp.demo.models.User;
import com.vnp.demo.repositories.SessionRepository;
import com.vnp.demo.repositories.UserRepository;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;
import org.springframework.web.server.ResponseStatusException;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.time.Instant;
import java.util.Base64;
import java.util.HexFormat;
@Service
public class AuthService {
private static final SecureRandom RANDOM = new SecureRandom();
private final UserRepository userRepository;
private final SessionRepository sessionRepository;
private final SessionCacheService sessionCacheService;
private final PasswordEncoder passwordEncoder;
private final TransactionTemplate transactions;
private final long sessionTtlSeconds;
public AuthService(
UserRepository userRepository,
SessionRepository sessionRepository,
SessionCacheService sessionCacheService,
PasswordEncoder passwordEncoder,
PlatformTransactionManager transactionManager,
@Value("${app.session.ttl-seconds:3600}") long sessionTtlSeconds
) {
if (sessionTtlSeconds <= 0) {
throw new IllegalArgumentException("Session TTL must be positive");
}
this.userRepository = userRepository;
this.sessionRepository = sessionRepository;
this.sessionCacheService = sessionCacheService;
this.passwordEncoder = passwordEncoder;
this.transactions = new TransactionTemplate(transactionManager);
this.sessionTtlSeconds = sessionTtlSeconds;
}
public SessionResponse login(String username, String password) {
byte[] bytes = new byte[32];
RANDOM.nextBytes(bytes);
String token = Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
String tokenHash = hashToken(token);
Instant expiresAt = Instant.now().plusSeconds(sessionTtlSeconds);
// TransactionTemplate returns only after the database commit completes.
UserResponse userResponse = transactions.execute(status -> {
User user = userRepository.findByUsername(username)
.orElseThrow(BusinessException::unauthorized);
if (!passwordEncoder.matches(password, user.getPasswordHash())) {
throw BusinessException.unauthorized();
}
sessionRepository.save(new Session(user, tokenHash, expiresAt));
return new UserResponse(
user.getId(), user.getUsername(),
user.getDisplayName(), user.getCreatedAt()
);
});
// Never publish a usable token before the PostgreSQL commit.
// If Redis fails, the DB row remains inert: it cannot authenticate.
try {
sessionCacheService.cache(tokenHash, userResponse.id(), expiresAt);
} catch (RuntimeException activationFailure) {
// The token is never returned. Best-effort cleanup handles an
// uncertain Redis write and records the failed activation in PG.
try {
sessionCacheService.invalidate(tokenHash);
} catch (RuntimeException cleanupFailure) {
activationFailure.addSuppressed(cleanupFailure);
}
try {
transactions.executeWithoutResult(status ->
sessionRepository.findByTokenHash(tokenHash)
.ifPresent(Session::revoke)
);
} catch (RuntimeException cleanupFailure) {
activationFailure.addSuppressed(cleanupFailure);
}
throw activationFailure;
}
return new SessionResponse(token, "Bearer", expiresAt, userResponse);
}
public User authenticate(String token) {
if (token == null || token.isBlank()) {
throw BusinessException.unauthorized();
}
var cached = sessionCacheService.find(hashToken(token))
.orElseThrow(BusinessException::unauthorized);
return userRepository.findById(cached.userId())
.orElseThrow(BusinessException::unauthorized);
}
public void logout(String token) {
if (token == null || token.isBlank()) {
throw BusinessException.unauthorized();
}
String tokenHash = hashToken(token);
if (sessionCacheService.find(tokenHash).isEmpty()) {
throw BusinessException.unauthorized();
}
if (!sessionCacheService.invalidate(tokenHash)) {
throw BusinessException.unauthorized();
}
transactions.executeWithoutResult(status -> {
Session session = sessionRepository.findByTokenHash(tokenHash)
.orElseThrow(() -> new ResponseStatusException(
HttpStatus.SERVICE_UNAVAILABLE, "Session record unavailable"));
session.revoke();
});
}
private String hashToken(String token) {
try {
byte[] hash = MessageDigest.getInstance("SHA-256")
.digest(token.getBytes(StandardCharsets.UTF_8));
return HexFormat.of().formatHex(hash);
} catch (NoSuchAlgorithmException ex) {
throw new IllegalStateException("SHA-256 unavailable", ex);
}
}
}
@@ -0,0 +1,195 @@
package com.vnp.demo.service;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.vnp.demo.BusinessException;
import com.vnp.demo.CursorCodec;
import com.vnp.demo.dto.ChatCreateRequest;
import com.vnp.demo.dto.ChatPageResponse;
import com.vnp.demo.dto.ChatResponse;
import com.vnp.demo.models.Chat;
import com.vnp.demo.models.ChatMember;
import com.vnp.demo.models.User;
import com.vnp.demo.repositories.ChatMemberRepository;
import com.vnp.demo.repositories.ChatRepository;
import com.vnp.demo.repositories.UserRepository;
@Service
public class ChatService {
private final ChatRepository chatRepository;
private final ChatMemberRepository chatMemberRepository;
private final UserRepository userRepository;
private final CursorCodec cursorCodec;
public ChatService(
ChatRepository chatRepository,
ChatMemberRepository chatMemberRepository,
UserRepository userRepository,
CursorCodec cursorCodec
) {
this.chatRepository = chatRepository;
this.chatMemberRepository = chatMemberRepository;
this.userRepository = userRepository;
this.cursorCodec = cursorCodec;
}
@Transactional
public ChatResponse create(
UUID currentUserId,
ChatCreateRequest request
) {
String title = request.title();
if (title == null
|| title.isBlank()
|| title.codePointCount(0, title.length()) > 100) {
throw BusinessException.invalid(
"Некорректное название чата"
);
}
List<UUID> memberIds = request.memberIds();
if (memberIds == null
|| memberIds.isEmpty()
|| !memberIds.contains(currentUserId)) {
throw BusinessException.invalid(
"Создатель должен быть участником чата"
);
}
if (memberIds.stream().distinct().count() != memberIds.size()) {
throw BusinessException.invalid(
"Список участников содержит дубликаты"
);
}
List<User> users = userRepository.findAllById(memberIds);
if (users.size() != memberIds.size()) {
throw BusinessException.invalid("Один или несколько участников не найдены");
}
// Создаём чат через конструктор существующей модели.
Chat chat = new Chat(title);
chatRepository.save(chat);
// Создание чата и участников происходит в одной транзакции.
for (User user : users) {
ChatMember member = new ChatMember(chat, user);
chatMemberRepository.save(member);
}
return toResponse(chat, memberIds);
}
@Transactional(readOnly = true)
public ChatResponse get(
UUID currentUserId,
UUID chatId
) {
Chat chat = chatRepository.findById(chatId)
.orElseThrow(BusinessException::notFound);
if (!chatMemberRepository.existsByIdChatIdAndIdUserId(
chatId,
currentUserId
)) {
throw BusinessException.notFound();
}
return toResponse(chat, getMemberIds(chatId));
}
@Transactional(readOnly = true)
public ChatPageResponse list(
UUID currentUserId,
Integer limit,
String cursor
) {
int pageSize = limit == null ? 20 : limit;
if (pageSize < 1 || pageSize > 100) {
throw BusinessException.invalid(
"limit должен быть от 1 до 100"
);
}
List<Chat> chats;
if (cursor == null) {
chats = chatRepository.findFirstPage(
currentUserId,
PageRequest.of(0, pageSize + 1)
);
} else {
CursorCodec.ChatCursor decoded =
cursorCodec.decodeChat(cursor, currentUserId);
chats = chatRepository.findNextPage(
currentUserId,
decoded.createdAt(),
decoded.id(),
PageRequest.of(0, pageSize + 1)
);
}
boolean hasNext = chats.size() > pageSize;
List<Chat> page = hasNext
? chats.subList(0, pageSize)
: chats;
List<ChatResponse> items = new ArrayList<>();
for (Chat chat : page) {
items.add(
toResponse(
chat,
getMemberIds(chat.getId())
)
);
}
String nextCursor = null;
if (hasNext && !page.isEmpty()) {
Chat last = page.get(page.size() - 1);
nextCursor = cursorCodec.encodeChat(
currentUserId,
last.getCreatedAt(),
last.getId()
);
}
return new ChatPageResponse(items, nextCursor);
}
private List<UUID> getMemberIds(UUID chatId) {
return chatMemberRepository.findByIdChatId(chatId)
.stream()
.map(member -> member.getId().getUserId())
.sorted()
.toList();
}
private ChatResponse toResponse(
Chat chat,
List<UUID> memberIds
) {
return new ChatResponse(
chat.getId(),
chat.getTitle(),
memberIds,
chat.getCreatedAt()
);
}
}
@@ -0,0 +1,323 @@
package com.vnp.demo.service;
import java.util.HashSet;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.vnp.demo.BusinessException;
import com.vnp.demo.CursorCodec;
import com.vnp.demo.dto.MessageCreateRequest;
import com.vnp.demo.dto.MessagePageResponse;
import com.vnp.demo.dto.MessageResponse;
import com.vnp.demo.models.Attachment;
import com.vnp.demo.models.Chat;
import com.vnp.demo.models.Message;
import com.vnp.demo.models.User;
import com.vnp.demo.repositories.AttachmentRepository;
import com.vnp.demo.repositories.ChatMemberRepository;
import com.vnp.demo.repositories.ChatRepository;
import com.vnp.demo.repositories.MessageRepository;
import com.vnp.demo.repositories.UserRepository;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
@Service
public class MessageService {
private final MessageRepository messageRepository;
private final ChatRepository chatRepository;
private final ChatMemberRepository chatMemberRepository;
private final UserRepository userRepository;
private final AttachmentRepository attachmentRepository;
private final CursorCodec cursorCodec;
@PersistenceContext
private EntityManager entityManager;
public MessageService(
MessageRepository messageRepository,
ChatRepository chatRepository,
ChatMemberRepository chatMemberRepository,
UserRepository userRepository,
AttachmentRepository attachmentRepository,
CursorCodec cursorCodec
) {
this.messageRepository = messageRepository;
this.chatRepository = chatRepository;
this.chatMemberRepository = chatMemberRepository;
this.userRepository = userRepository;
this.attachmentRepository = attachmentRepository;
this.cursorCodec = cursorCodec;
}
@Transactional
public MessageResponse create(
UUID userId,
UUID chatId,
MessageCreateRequest request,
String key
) {
if (key == null
|| !key.matches("[A-Za-z0-9._:-]{1,128}")) {
throw BusinessException.invalid(
"Некорректный Idempotency-Key"
);
}
checkAccess(userId, chatId);
List<UUID> attachmentIds = validateRequest(request);
String attachmentSignature = attachmentIds.stream()
.map(UUID::toString)
.collect(Collectors.joining(","));
String scope = userId + ":" + chatId + ":" + key;
entityManager.createNativeQuery(
"""
SELECT 1
FROM pg_advisory_xact_lock(
hashtextextended(:scope, 0)
)
"""
).setParameter("scope", scope).getResultList();
@SuppressWarnings("unchecked")
List<Object[]> existing = entityManager.createNativeQuery(
"""
SELECT message_id, request_text, request_attachment_ids
FROM message_idempotency
WHERE user_id = :user
AND chat_id = :chat
AND key = :key
"""
)
.setParameter("user", userId)
.setParameter("chat", chatId)
.setParameter("key", key)
.getResultList();
if (!existing.isEmpty()) {
Object[] row = existing.get(0);
boolean sameText = request.text().equals(row[1]);
boolean sameAttachments =
attachmentSignature.equals(row[2]);
if (!sameText || !sameAttachments) {
throw BusinessException.conflict(
"Ключ уже использован с другим сообщением"
);
}
Message original = messageRepository
.findById((UUID) row[0])
.orElseThrow(BusinessException::notFound);
return toResponse(original);
}
validateAttachments(chatId, attachmentIds);
Chat chat = chatRepository.findById(chatId)
.orElseThrow(BusinessException::notFound);
User sender = userRepository.findById(userId)
.orElseThrow(BusinessException::unauthorized);
Message message = new Message(
chat,
sender,
request.text(),
attachmentIds
);
Message saved = messageRepository.saveAndFlush(message);
entityManager.refresh(saved);
entityManager.createNativeQuery(
"""
INSERT INTO message_idempotency (
user_id,
chat_id,
key,
request_text,
request_attachment_ids,
message_id
)
VALUES (
:user,
:chat,
:key,
:text,
:attachments,
:message
)
"""
)
.setParameter("user", userId)
.setParameter("chat", chatId)
.setParameter("key", key)
.setParameter("text", request.text())
.setParameter("attachments", attachmentSignature)
.setParameter("message", saved.getId())
.executeUpdate();
return toResponse(saved);
}
private List<UUID> validateRequest(
MessageCreateRequest request
) {
if (request == null || request.text() == null) {
throw BusinessException.invalid(
"Поле text обязательно"
);
}
if (request.text().codePointCount(
0,
request.text().length()
) > 4000) {
throw BusinessException.invalid(
"Текст не должен превышать 4000 символов"
);
}
List<UUID> attachmentIds = request.attachmentIds();
if (attachmentIds == null
|| attachmentIds.size() > 10
|| attachmentIds.stream().anyMatch(id -> id == null)) {
throw BusinessException.invalid(
"attachment_ids должен содержать от 0 до 10 UUID"
);
}
if (new HashSet<>(attachmentIds).size()
!= attachmentIds.size()) {
throw BusinessException.invalid(
"Повторяющиеся вложения недопустимы"
);
}
if (request.text().isBlank() && attachmentIds.isEmpty()) {
throw BusinessException.invalid(
"Сообщение должно содержать текст или вложение"
);
}
return List.copyOf(attachmentIds);
}
private void validateAttachments(
UUID chatId,
List<UUID> attachmentIds
) {
for (UUID attachmentId : attachmentIds) {
Attachment attachment = attachmentRepository
.findById(attachmentId)
.orElseThrow(BusinessException::notFound);
if (!chatId.equals(attachment.chatId())) {
throw BusinessException.notFound();
}
if (!"ready".equals(attachment.status())) {
throw BusinessException.conflict(
"Вложение не готово"
);
}
}
}
@Transactional(readOnly = true)
public MessagePageResponse list(
UUID userId,
UUID chatId,
int limit,
String cursor
) {
checkAccess(userId, chatId);
if (limit < 1 || limit > 100) {
throw BusinessException.invalid(
"limit должен быть от 1 до 100"
);
}
CursorCodec.MessageCursor position = null;
if (cursor != null) {
position = cursorCodec.decodeMessage(cursor, chatId);
}
List<Message> messages;
if (position == null) {
messages = messageRepository.findFirstPage(
chatId,
PageRequest.of(0, limit + 1)
);
} else {
messages = messageRepository.findNextPage(
chatId,
position.createdAt(),
position.id(),
PageRequest.of(0, limit + 1)
);
}
boolean hasNext = messages.size() > limit;
List<Message> page = hasNext
? messages.subList(0, limit)
: messages;
List<MessageResponse> items = page.stream()
.map(this::toResponse)
.toList();
String nextCursor = null;
if (hasNext && !page.isEmpty()) {
Message last = page.get(page.size() - 1);
nextCursor = cursorCodec.encodeMessage(
chatId,
last.getCreatedAt(),
last.getId()
);
}
return new MessagePageResponse(items, nextCursor);
}
private void checkAccess(UUID userId, UUID chatId) {
boolean member = chatMemberRepository
.existsByIdChatIdAndIdUserId(chatId, userId);
if (!member) {
throw BusinessException.notFound();
}
}
private MessageResponse toResponse(Message message) {
return new MessageResponse(
message.getId(),
message.getChat().getId(),
message.getSender().getId(),
message.getText(),
message.getCreatedAt(),
List.copyOf(message.getAttachmentIds())
);
}
}
@@ -0,0 +1,194 @@
package com.vnp.demo.service;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Instant;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import com.vnp.demo.BusinessException;
import com.vnp.demo.validation.ImageValidator;
import io.minio.BucketExistsArgs;
import io.minio.GetObjectArgs;
import io.minio.ListObjectsArgs;
import io.minio.MinioClient;
import io.minio.PutObjectArgs;
import io.minio.RemoveObjectArgs;
import io.minio.Result;
import io.minio.StatObjectArgs;
import io.minio.StatObjectResponse;
import io.minio.errors.ErrorResponseException;
import io.minio.messages.Item;
import okhttp3.OkHttpClient;
@Service
public class S3StorageService {
private final MinioClient client;
private final String bucket;
public S3StorageService(
@Value("${app.s3.endpoint}") String endpoint,
@Value("${app.s3.access-key}") String accessKey,
@Value("${app.s3.secret-key}") String secretKey,
@Value("${app.s3.bucket}") String bucket
) {
this.bucket = bucket;
OkHttpClient httpClient = new OkHttpClient.Builder()
.connectTimeout(2, TimeUnit.SECONDS)
.writeTimeout(10, TimeUnit.SECONDS)
.readTimeout(10, TimeUnit.SECONDS)
.callTimeout(30, TimeUnit.SECONDS)
.retryOnConnectionFailure(false)
.build();
this.client = MinioClient.builder()
.endpoint(endpoint)
.credentials(accessKey, secretKey)
.region("us-east-1")
.httpClient(httpClient)
.build();
}
public void put(
String objectKey,
Path file,
long sizeBytes,
String contentType
) {
if (sizeBytes < 1
|| sizeBytes > ImageValidator.MAX_BYTES) {
throw new BusinessException(
"payload_too_large",
"Некорректный размер загружаемого файла",
HttpStatus.PAYLOAD_TOO_LARGE
);
}
try (InputStream input = Files.newInputStream(file)) {
client.putObject(
PutObjectArgs.builder()
.bucket(bucket)
.object(objectKey)
.contentType(contentType)
.stream(input, sizeBytes, ImageValidator.MAX_BYTES)
.build()
);
} catch (Exception e) {
throw unavailable();
}
}
public byte[] get(
String objectKey,
long expectedSize,
String expectedSha256
) {
if (expectedSize < 1
|| expectedSize > ImageValidator.MAX_BYTES) {
throw unavailable();
}
try (InputStream input = client.getObject(
GetObjectArgs.builder()
.bucket(bucket)
.object(objectKey)
.build()
)) {
byte[] bytes = input.readNBytes(
Math.toIntExact(expectedSize) + 1
);
if (bytes.length != expectedSize
|| !ImageValidator.sha256(bytes)
.equals(expectedSha256)) {
throw unavailable();
}
return bytes;
} catch (BusinessException e) {
throw e;
} catch (Exception e) {
throw unavailable();
}
}
public Iterable<Result<Item>> listOriginals() {
return client.listObjects(
ListObjectsArgs.builder()
.bucket(bucket)
.prefix("originals/")
.recursive(true)
.build()
);
}
public Instant lastModifiedOrNull(String objectKey) {
try {
StatObjectResponse response = client.statObject(
StatObjectArgs.builder()
.bucket(bucket)
.object(objectKey)
.build()
);
return response.lastModified().toInstant();
} catch (ErrorResponseException e) {
String code = e.errorResponse().code();
if ("NoSuchKey".equals(code)
|| "NoSuchObject".equals(code)) {
return null;
}
throw unavailable();
} catch (Exception e) {
throw unavailable();
}
}
public void remove(String objectKey) {
try {
client.removeObject(
RemoveObjectArgs.builder()
.bucket(bucket)
.object(objectKey)
.build()
);
} catch (Exception e) {
throw unavailable();
}
}
public void checkReady() {
try {
boolean exists = client.bucketExists(
BucketExistsArgs.builder()
.bucket(bucket)
.build()
);
if (!exists) {
throw unavailable();
}
} catch (BusinessException e) {
throw e;
} catch (Exception e) {
throw unavailable();
}
}
private static BusinessException unavailable() {
return new BusinessException(
"unavailable",
"Хранилище файлов временно недоступно",
HttpStatus.SERVICE_UNAVAILABLE
);
}
}
@@ -0,0 +1,72 @@
package com.vnp.demo.service;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.vnp.demo.SessionStoreUnavailableException;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.web.server.ResponseStatusException;
import java.time.Duration;
import java.time.Instant;
import java.util.Optional;
import java.util.UUID;
@Service
public class SessionCacheService {
private static final String PREFIX = "session:";
private final StringRedisTemplate redis;
private final ObjectMapper mapper;
public SessionCacheService(StringRedisTemplate redis, ObjectMapper mapper) {
this.redis = redis;
this.mapper = mapper;
}
public record CachedSession(UUID userId, Instant expiresAt) {}
public Optional<CachedSession> find(String tokenHash) {
try {
String json = redis.opsForValue().get(PREFIX + tokenHash);
if (json == null) return Optional.empty();
CachedSession session = mapper.readValue(json, CachedSession.class);
if (!session.expiresAt().isAfter(Instant.now())) return Optional.empty();
return Optional.of(session);
} catch (DataAccessException ex) {
throw unavailable(ex);
} catch (JsonProcessingException | IllegalArgumentException ex) {
throw unavailable(ex);
}
}
public void cache(String tokenHash, UUID userId, Instant expiresAt) {
Duration ttl = Duration.between(Instant.now(), expiresAt);
if (ttl.isNegative() || ttl.isZero()) {
throw new IllegalStateException("Session already expired");
}
try {
String json = mapper.writeValueAsString(new CachedSession(userId, expiresAt));
redis.opsForValue().set(PREFIX + tokenHash, json, ttl);
} catch (DataAccessException ex) {
throw unavailable(ex);
} catch (JsonProcessingException ex) {
throw new IllegalStateException("Cannot serialize session", ex);
}
}
public boolean invalidate(String tokenHash) {
try {
Boolean deleted = redis.delete(PREFIX + tokenHash);
return Boolean.TRUE.equals(deleted);
} catch (DataAccessException ex) {
throw new SessionStoreUnavailableException(ex);
}
}
private ResponseStatusException unavailable(Exception ex) {
return new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE, "Session store unavailable", ex);
}
}
@@ -0,0 +1,58 @@
package com.vnp.demo.service;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicBoolean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import com.vnp.demo.BusinessException;
@Component
public class UploadLimiter {
private final Semaphore semaphore;
public UploadLimiter(
@Value("${app.uploads.max-concurrent:1}")
int maxConcurrent
) {
if (maxConcurrent < 1) {
throw new IllegalArgumentException(
"max-concurrent должен быть больше нуля"
);
}
this.semaphore = new Semaphore(maxConcurrent);
}
public Permit acquire() {
if (!semaphore.tryAcquire()) {
throw new BusinessException(
"rate_limited",
"Все обработчики загрузки заняты. Повторите запрос позже",
HttpStatus.TOO_MANY_REQUESTS
);
}
return new Permit(semaphore);
}
public static final class Permit implements AutoCloseable {
private final Semaphore semaphore;
private final AtomicBoolean released = new AtomicBoolean(false);
private Permit(Semaphore semaphore) {
this.semaphore = semaphore;
}
@Override
public void close() {
if (released.compareAndSet(false, true)) {
semaphore.release();
}
}
}
}
@@ -0,0 +1,86 @@
package com.vnp.demo.service;
import java.util.UUID;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;
import com.vnp.demo.BusinessException;
import com.vnp.demo.dto.UserCreateRequest;
import com.vnp.demo.dto.UserResponse;
import com.vnp.demo.models.User;
import com.vnp.demo.repositories.UserRepository;
import com.vnp.demo.validation.UserInputValidator;
@Service
public class UserService {
private final UserRepository userRepository;
private final PasswordEncoder passwordEncoder;
private final TransactionTemplate transactionTemplate;
public UserService(
UserRepository userRepository,
PasswordEncoder passwordEncoder,
TransactionTemplate transactionTemplate
) {
this.userRepository = userRepository;
this.passwordEncoder = passwordEncoder;
this.transactionTemplate = transactionTemplate;
}
public UserResponse register(UserCreateRequest request) {
String username = request.username();
String displayName = request.displayName();
String password = request.password();
UserInputValidator.validate(displayName, password);
String passwordHash = passwordEncoder.encode(password);
try {
return transactionTemplate.execute(status -> {
if (userRepository.existsByUsername(username)) {
throw BusinessException.conflict("Username already exists");
}
User user = new User(
username,
displayName,
passwordHash
);
User saved = userRepository.saveAndFlush(user);
return toResponse(saved);
});
} catch (DataIntegrityViolationException ex) {
throw BusinessException.conflict(
"Username already exists"
);
}
}
@org.springframework.transaction.annotation.Transactional(readOnly = true)
public UserResponse getCurrent(UUID userId) {
User user = userRepository.findById(userId)
.orElseThrow(BusinessException::notFound);
return toResponse(user);
}
public UserResponse toResponse(User user) {
return new UserResponse(
user.getId(),
user.getUsername(),
user.getDisplayName(),
user.getCreatedAt()
);
}
}
@@ -0,0 +1,481 @@
package com.vnp.demo.validation;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.time.Instant;
import java.util.HexFormat;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.stream.FileImageInputStream;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import com.vnp.demo.BusinessException;
@Component
public class ImageValidator {
public static final int MAX_BYTES = 10 * 1024 * 1024;
public static final long MAX_PIXELS = 40_000_000L;
private static final int BUFFER_SIZE = 64 * 1024;
private static final long MAX_RECEIVE_NANOS =
TimeUnit.SECONDS.toNanos(60);
private static final long TEMP_FILE_GRACE_SECONDS = 3600;
private static final Logger log =
LoggerFactory.getLogger(ImageValidator.class);
private static final Set<Path> ACTIVE_FILES =
ConcurrentHashMap.newKeySet();
private final Path tempDirectory;
public ImageValidator(
@Value("${app.uploads.temp-dir:/tmp/messenger-uploads}")
String tempDirectory
) {
this.tempDirectory = Path.of(tempDirectory)
.toAbsolutePath()
.normalize();
try {
Files.createDirectories(this.tempDirectory);
} catch (IOException e) {
throw new IllegalStateException(
"Не удалось создать каталог временных загрузок",
e
);
}
}
public record ValidatedImage(
Path path,
long sizeBytes,
String contentType,
String sha256
) implements AutoCloseable {
@Override
public void close() {
deleteTemporaryFile(path);
}
}
public void validateFilename(String filename) {
if (filename == null) {
throw BusinessException.invalid(
"Не указано имя файла"
);
}
int length = filename.codePointCount(
0,
filename.length()
);
if (length < 1 || length > 255) {
throw BusinessException.invalid(
"Имя файла должно содержать от 1 до 255 символов"
);
}
boolean unsafe = filename.codePoints().anyMatch(
codePoint -> codePoint == '/'
|| codePoint == '\\'
|| Character.isISOControl(codePoint)
);
if (unsafe) {
throw BusinessException.invalid(
"Имя файла содержит недопустимые символы"
);
}
}
public ValidatedImage validate(
InputStream input,
long contentLength,
String declaredContentType
) {
if (contentLength > MAX_BYTES) {
throw tooLarge(
"Размер файла превышает 10 MiB"
);
}
String declaredMime = normalizeMime(
declaredContentType
);
Path temporaryFile = createTemporaryFile();
boolean success = false;
try {
MessageDigest digest = newSha256();
long size = copyLimited(
input,
temporaryFile,
digest
);
if (size == 0) {
throw unsupported();
}
if (contentLength >= 0 && size != contentLength) {
throw BusinessException.invalid(
"Тело запроса получено не полностью"
);
}
String actualMime = validateImageContent(
temporaryFile
);
if (!actualMime.equals(declaredMime)) {
throw unsupported();
}
String checksum = HexFormat.of()
.formatHex(digest.digest());
ValidatedImage result = new ValidatedImage(
temporaryFile,
size,
actualMime,
checksum
);
success = true;
return result;
} finally {
if (!success) {
deleteTemporaryFile(temporaryFile);
}
}
}
private Path createTemporaryFile() {
try {
Path file = Files.createTempFile(
tempDirectory,
"upload-",
".tmp"
);
ACTIVE_FILES.add(file);
return file;
} catch (IOException e) {
throw temporaryStorageUnavailable();
}
}
private long copyLimited(
InputStream input,
Path destination,
MessageDigest digest
) {
byte[] buffer = new byte[BUFFER_SIZE];
long total = 0;
long started = System.nanoTime();
try (OutputStream output =
Files.newOutputStream(destination)) {
while (true) {
checkReceiveDeadline(started);
int requested = (int) Math.min(
buffer.length,
(long) MAX_BYTES - total + 1
);
int count;
try {
count = input.read(buffer, 0, requested);
} catch (IOException e) {
throw BusinessException.invalid(
"Передача файла прервана или превышено время ожидания"
);
}
checkReceiveDeadline(started);
if (count == -1) {
break;
}
if (count == 0) {
continue;
}
total += count;
if (total > MAX_BYTES) {
throw tooLarge(
"Размер файла превышает 10 MiB"
);
}
output.write(buffer, 0, count);
digest.update(buffer, 0, count);
}
return total;
} catch (IOException e) {
throw temporaryStorageUnavailable();
}
}
private static void checkReceiveDeadline(long started) {
if (System.nanoTime() - started >= MAX_RECEIVE_NANOS) {
throw BusinessException.invalid(
"Превышено допустимое время приёма файла"
);
}
}
private String normalizeMime(String value) {
if (value == null) {
throw unsupported();
}
try {
MediaType type = MediaType.parseMediaType(value);
if (type.getType().equalsIgnoreCase("image")
&& type.getSubtype().equalsIgnoreCase("png")) {
return "image/png";
}
if (type.getType().equalsIgnoreCase("image")
&& type.getSubtype().equalsIgnoreCase("jpeg")) {
return "image/jpeg";
}
} catch (IllegalArgumentException e) {
throw unsupported();
}
throw unsupported();
}
private String validateImageContent(Path file) {
try (FileImageInputStream imageInput =
new FileImageInputStream(file.toFile())) {
Iterator<ImageReader> readers =
ImageIO.getImageReaders(imageInput);
if (!readers.hasNext()) {
throw unsupported();
}
ImageReader reader = readers.next();
try {
reader.setInput(imageInput, true, true);
String format = reader.getFormatName();
String mime;
if ("png".equalsIgnoreCase(format)) {
mime = "image/png";
} else if ("jpeg".equalsIgnoreCase(format)
|| "jpg".equalsIgnoreCase(format)) {
mime = "image/jpeg";
} else {
throw unsupported();
}
int width = reader.getWidth(0);
int height = reader.getHeight(0);
if (width <= 0 || height <= 0) {
throw unsupported();
}
long pixels = (long) width * height;
if (pixels > MAX_PIXELS) {
throw tooLarge(
"Изображение содержит более 40 миллионов пикселей"
);
}
AtomicBoolean warning = new AtomicBoolean(false);
reader.addIIOReadWarningListener(
(source, message) -> warning.set(true)
);
BufferedImage image = reader.read(0);
if (image == null) {
throw unsupported();
}
try {
if (warning.get()) {
throw unsupported();
}
} finally {
image.flush();
}
return mime;
} finally {
reader.dispose();
}
} catch (BusinessException e) {
throw e;
} catch (IOException | RuntimeException e) {
throw unsupported();
}
}
@Scheduled(
initialDelay = 60_000,
fixedDelay = 300_000
)
public void cleanupTemporaryFiles() {
Instant cutoff = Instant.now()
.minusSeconds(TEMP_FILE_GRACE_SECONDS);
long deleted = 0;
try (DirectoryStream<Path> files =
Files.newDirectoryStream(
tempDirectory,
"upload-*.tmp"
)) {
for (Path file : files) {
if (ACTIVE_FILES.contains(file)) {
continue;
}
if (!Files.isRegularFile(
file,
LinkOption.NOFOLLOW_LINKS
)) {
continue;
}
try {
Instant modified = Files.getLastModifiedTime(
file,
LinkOption.NOFOLLOW_LINKS
).toInstant();
if (!modified.isBefore(cutoff)) {
continue;
}
if (Files.deleteIfExists(file)) {
deleted++;
}
} catch (IOException e) {
log.warn(
"Не удалось очистить временный файл {}",
file.getFileName(),
e
);
}
}
log.info(
"Temporary upload cleanup completed: deleted={}",
deleted
);
} catch (IOException e) {
log.warn(
"Не удалось просмотреть каталог временных загрузок",
e
);
}
}
private static MessageDigest newSha256() {
try {
return MessageDigest.getInstance("SHA-256");
} catch (NoSuchAlgorithmException e) {
throw new IllegalStateException(
"SHA-256 недоступен",
e
);
}
}
public static String sha256(byte[] bytes) {
return HexFormat.of().formatHex(
newSha256().digest(bytes)
);
}
private static void deleteTemporaryFile(Path file) {
try {
Files.deleteIfExists(file);
} catch (IOException e) {
log.warn(
"Не удалось удалить временный файл {}",
file.getFileName(),
e
);
} finally {
ACTIVE_FILES.remove(file);
}
}
private static BusinessException unsupported() {
return new BusinessException(
"unsupported_media_type",
"Ожидается корректное изображение PNG или JPEG",
HttpStatus.UNSUPPORTED_MEDIA_TYPE
);
}
private static BusinessException tooLarge(String message) {
return new BusinessException(
"payload_too_large",
message,
HttpStatus.PAYLOAD_TOO_LARGE
);
}
private static BusinessException temporaryStorageUnavailable() {
return new BusinessException(
"unavailable",
"Временное хранилище загрузок недоступно",
HttpStatus.SERVICE_UNAVAILABLE
);
}
}
@@ -0,0 +1,32 @@
package com.vnp.demo.validation;
import com.vnp.demo.BusinessException;
public final class UserInputValidator {
private UserInputValidator() {
}
public static void validate(String displayName, String password) {
if (displayName == null
|| displayName.isBlank()
|| codePoints(displayName) > 100) {
throw BusinessException.invalid(
"Некорректное отображаемое имя"
);
}
if (password == null
|| codePoints(password) < 12
|| codePoints(password) > 128) {
throw BusinessException.invalid(
"Пароль должен содержать от 12 до 128 символов"
);
}
}
private static int codePoints(String value) {
return value.codePointCount(0, value.length());
}
}
+65
View File
@@ -0,0 +1,65 @@
server:
shutdown: graceful
tomcat:
threads:
max: 64
connection-timeout: 2s
spring:
application:
name: messenger
lifecycle:
timeout-per-shutdown-phase: 15s
jackson:
default-property-inclusion: always
deserialization:
fail-on-unknown-properties: true
fail-on-trailing-tokens: true
mapper:
allow-coercion-of-scalars: false
datasource:
url: ${DB_URL:jdbc:postgresql://localhost:5432/messenger}
username: ${DB_USERNAME:messenger}
password: ${DB_PASSWORD:messenger}
hikari:
maximum-pool-size: ${DB_POOL_SIZE:8}
minimum-idle: 1
connection-timeout: 1000
validation-timeout: 500
data-source-properties:
connectTimeout: 2
socketTimeout: 8
options: "-c statement_timeout=5000 -c lock_timeout=3000"
data:
redis:
host: ${REDIS_HOST:localhost}
port: 6379
password: ${REDIS_PASSWORD:}
timeout: 1s
connect-timeout: 1s
flyway:
enabled: ${FLYWAY_ENABLED:true}
jpa:
hibernate:
ddl-auto: validate
open-in-view: false
transaction:
default-timeout: 8s
app:
session:
ttl-seconds: 86400
s3:
endpoint: ${S3_ENDPOINT:http://localhost:9000}
access-key: ${S3_ACCESS_KEY:}
secret-key: ${S3_SECRET_KEY:}
bucket: ${S3_BUCKET:messenger-attachments}
uploads:
max-concurrent: ${UPLOAD_MAX_CONCURRENT:1}
temp-dir: ${UPLOAD_TEMP_DIR:/tmp/messenger-uploads}
cleanup:
enabled: ${ATTACHMENT_CLEANUP_ENABLED:true}
grace-seconds: ${ATTACHMENT_CLEANUP_GRACE_SECONDS:3600}
interval-ms: ${ATTACHMENT_CLEANUP_INTERVAL_MS:300000}
initial-delay-ms: ${ATTACHMENT_CLEANUP_INITIAL_DELAY_MS:60000}
@@ -0,0 +1,77 @@
CREATE TABLE users (
id UUID PRIMARY KEY,
username VARCHAR(32) NOT NULL UNIQUE,
display_name VARCHAR(400) NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
CONSTRAINT chk_username
CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT chk_display_name
CHECK (
char_length(display_name) BETWEEN 1 AND 100
AND length(btrim(display_name)) > 0
)
);
CREATE TABLE chats (
id UUID PRIMARY KEY,
title VARCHAR(400) NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
CONSTRAINT chk_chat_title
CHECK (
char_length(title) BETWEEN 1 AND 100
AND length(btrim(title)) > 0
)
);
CREATE TABLE chat_members (
chat_id UUID NOT NULL REFERENCES chats(id),
user_id UUID NOT NULL REFERENCES users(id),
PRIMARY KEY (chat_id, user_id)
);
CREATE TABLE messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id),
sender_id UUID NOT NULL,
text VARCHAR(16000) NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
CONSTRAINT fk_message_membership
FOREIGN KEY (chat_id, sender_id)
REFERENCES chat_members(chat_id, user_id),
CONSTRAINT chk_message_text
CHECK (
char_length(text) BETWEEN 1 AND 4000
AND length(btrim(text)) > 0
)
);
CREATE TABLE sessions (
id UUID PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users(id),
token_hash CHAR(64) NOT NULL UNIQUE,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
expires_at TIMESTAMPTZ NOT NULL,
revoked_at TIMESTAMPTZ,
CONSTRAINT chk_session_expiry
CHECK (expires_at > created_at)
);
CREATE INDEX idx_chat_members_user
ON chat_members(user_id, chat_id);
CREATE INDEX idx_chats_history
ON chats(created_at, id);
CREATE INDEX idx_messages_history
ON messages(chat_id, created_at, id);
CREATE INDEX idx_sessions_user
ON sessions(user_id);
@@ -0,0 +1,9 @@
CREATE TABLE message_idempotency (
user_id UUID NOT NULL REFERENCES users(id),
chat_id UUID NOT NULL REFERENCES chats(id),
key VARCHAR(128) COLLATE "C" NOT NULL,
request_text TEXT NOT NULL,
message_id UUID NOT NULL UNIQUE REFERENCES messages(id),
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
PRIMARY KEY (user_id, chat_id, key)
);
@@ -0,0 +1,67 @@
CREATE TABLE attachments (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id),
owner_id UUID NOT NULL REFERENCES users(id),
filename TEXT NOT NULL,
content_type VARCHAR(32) NOT NULL,
size_bytes BIGINT NOT NULL,
sha256 CHAR(64) NOT NULL,
object_key TEXT NOT NULL UNIQUE,
status VARCHAR(16) NOT NULL DEFAULT 'ready',
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL,
CONSTRAINT chk_attachment_filename
CHECK (char_length(filename) BETWEEN 1 AND 255),
CONSTRAINT chk_attachment_content_type
CHECK (content_type IN ('image/png', 'image/jpeg')),
CONSTRAINT chk_attachment_size
CHECK (size_bytes BETWEEN 1 AND 10485760),
CONSTRAINT chk_attachment_sha256
CHECK (sha256 ~ '^[a-f0-9]{64}$'),
CONSTRAINT chk_attachment_status
CHECK (status = 'ready'),
CONSTRAINT fk_attachment_membership
FOREIGN KEY (chat_id, owner_id)
REFERENCES chat_members(chat_id, user_id)
);
CREATE INDEX idx_attachments_chat
ON attachments(chat_id, created_at, id);
CREATE TABLE message_attachments (
message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
attachment_id UUID NOT NULL REFERENCES attachments(id),
position INTEGER NOT NULL,
PRIMARY KEY (message_id, position),
CONSTRAINT uq_message_attachment
UNIQUE (message_id, attachment_id),
CONSTRAINT chk_attachment_position
CHECK (position BETWEEN 0 AND 9)
);
CREATE INDEX idx_message_attachments_attachment
ON message_attachments(attachment_id);
ALTER TABLE messages
DROP CONSTRAINT chk_message_text;
ALTER TABLE messages
ADD CONSTRAINT chk_message_text
CHECK (char_length(text) BETWEEN 0 AND 4000);
-- Старые запросы не содержали вложений, поэтому для них значение пустое.
ALTER TABLE message_idempotency
ADD COLUMN request_attachment_ids TEXT NOT NULL DEFAULT '';
@@ -0,0 +1,89 @@
package com.vnp.demo;
import java.util.UUID;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.ResponseEntity;
import com.vnp.demo.dto.UserCreateRequest;
import com.vnp.demo.repositories.UserRepository;
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ConcurrentRegistrationTest {
@Autowired
private TestRestTemplate restTemplate;
@Autowired
private UserRepository userRepository;
@Test
void concurrentRegistrationAllowsOnlyOneUser() throws Exception {
String username = "race_" +
UUID.randomUUID().toString().substring(0, 8);
UserCreateRequest request = new UserCreateRequest(
username,
"Race Test",
"Password123!"
);
ExecutorService executor = Executors.newFixedThreadPool(2);
CountDownLatch start = new CountDownLatch(1);
try {
Callable<ResponseEntity<String>> task = () -> {
start.await();
return restTemplate.postForEntity(
"/api/v1/users",
request,
String.class
);
};
Future<ResponseEntity<String>> first =
executor.submit(task);
Future<ResponseEntity<String>> second =
executor.submit(task);
start.countDown();
int status1 = first.get(15, TimeUnit.SECONDS)
.getStatusCode().value();
int status2 = second.get(15, TimeUnit.SECONDS)
.getStatusCode().value();
assertTrue(
(status1 == 201 && status2 == 409)
|| (status1 == 409 && status2 == 201),
"Expected 201 and 409, got " +
status1 + " and " + status2
);
assertEquals(
1,
userRepository.findAll().stream()
.filter(user ->
username.equals(user.getUsername()))
.count()
);
} finally {
executor.shutdownNow();
}
}
}
@@ -0,0 +1,155 @@
package com.vnp.demo;
import java.time.Instant;
import java.util.UUID;
import static org.hamcrest.Matchers.equalTo;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doThrow;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.SpyBean;
import org.springframework.boot.test.web.server.LocalServerPort;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.security.crypto.password.PasswordEncoder;
import com.vnp.demo.models.User;
import com.vnp.demo.repositories.UserRepository;
import com.vnp.demo.service.SessionCacheService;
import io.restassured.RestAssured;
import static io.restassured.RestAssured.given;
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class InfrastructureFailureIntegrationTest {
@LocalServerPort
private int port;
@SpyBean
private UserRepository userRepository;
@Autowired
private PasswordEncoder passwordEncoder;
@SpyBean
private SessionCacheService sessionCacheService;
private String username;
private final String password = "Password123!";
@BeforeEach
void setUp() {
RestAssured.baseURI = "http://localhost";
RestAssured.port = port;
username = "failure_" + UUID.randomUUID()
.toString()
.substring(0, 8);
User user = new User(
username,
"Failure Test",
passwordEncoder.encode(password)
);
userRepository.saveAndFlush(user);
}
@Test
void redisUnavailableDuringLoginReturns503() {
doThrow(new DataAccessResourceFailureException(
"Redis unavailable"
)).when(sessionCacheService).cache(
anyString(),
any(UUID.class),
any(Instant.class)
);
given()
.auth()
.preemptive()
.basic(username, password)
.when()
.post("/api/v1/auth/sessions")
.then()
.statusCode(503)
.body(
"error.code",
equalTo("service_unavailable")
);
}
@Test
void anonymousUserCannotBypassAuthentication() {
given()
.header(
"X-User-Id",
UUID.randomUUID().toString()
)
.when()
.get("/api/v1/users/me")
.then()
.statusCode(401);
}
@Test
void redisUnavailableDuringAuthenticationDoesNotGrantAccess() {
String token = given()
.auth()
.preemptive()
.basic(username, password)
.when()
.post("/api/v1/auth/sessions")
.then()
.statusCode(201)
.extract()
.path("token");
doThrow(new DataAccessResourceFailureException(
"Redis unavailable"
)).when(sessionCacheService).find(anyString());
given()
.header(
"Authorization",
"Bearer " + token
)
.when()
.get("/api/v1/users/me")
.then()
.statusCode(503)
.body(
"error.code",
equalTo("service_unavailable")
);
}
@Test
void databaseUnavailableDuringLoginReturns503() {
doThrow(new DataAccessResourceFailureException(
"PostgreSQL unavailable"
)).when(userRepository).findByUsername(
eq(username)
);
given()
.auth()
.preemptive()
.basic(username, password)
.when()
.post("/api/v1/auth/sessions")
.then()
.statusCode(503)
.body(
"error.code",
equalTo("service_unavailable")
);
}
}
@@ -0,0 +1,154 @@
package com.vnp.demo;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.UUID;
import static org.hamcrest.Matchers.equalTo;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.server.LocalServerPort;
import org.springframework.security.crypto.password.PasswordEncoder;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.vnp.demo.models.User;
import com.vnp.demo.repositories.UserRepository;
import io.restassured.RestAssured;
import static io.restassured.RestAssured.given;
@SpringBootTest(
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
properties = "app.session.ttl-seconds=2"
)
class SessionIntegrationTest {
private static final String PASSWORD = "TestPassword123!";
@LocalServerPort
private int port;
@Autowired
private ObjectMapper mapper;
@Autowired
private UserRepository userRepository;
@Autowired
private PasswordEncoder passwordEncoder;
private String username;
@BeforeEach
void setUp() {
RestAssured.baseURI = "http://localhost";
RestAssured.port = port;
username = "test_" + UUID.randomUUID()
.toString().substring(0, 8);
userRepository.saveAndFlush(
new User(
username,
"Test User",
passwordEncoder.encode(PASSWORD)
)
);
}
private String login(String password) throws Exception {
String credentials = username + ":" + password;
String basic = Base64.getEncoder().encodeToString(
credentials.getBytes(StandardCharsets.UTF_8)
);
var response = given()
.header("Authorization", "Basic " + basic)
.post("/api/v1/auth/sessions");
response.then().log().all();
response.then().statusCode(201);
JsonNode json = mapper.readTree(response.asString());
return json.get("token").asText();
}
@Test
void validSessionAllowsAccess() throws Exception {
String token = login(PASSWORD);
given()
.header("Authorization", "Bearer " + token)
.get("/api/v1/users/me")
.then()
.statusCode(200)
.body("username", equalTo(username));
}
@Test
void expiredSessionReturns401() throws Exception {
String token = login(PASSWORD);
Thread.sleep(3000);
given()
.header("Authorization", "Bearer " + token)
.get("/api/v1/users/me")
.then()
.statusCode(401);
}
@Test
void logoutRevokesSession() throws Exception {
String token = login(PASSWORD);
given()
.header("Authorization", "Bearer " + token)
.delete("/api/v1/auth/sessions/current")
.then()
.statusCode(204);
given()
.header("Authorization", "Bearer " + token)
.get("/api/v1/users/me")
.then()
.statusCode(401);
}
@Test
void wrongPasswordReturns401() {
String credentials = username + ":WrongPassword123!";
String basic = Base64.getEncoder().encodeToString(
credentials.getBytes(StandardCharsets.UTF_8)
);
given()
.header("Authorization", "Basic " + basic)
.post("/api/v1/auth/sessions")
.then()
.statusCode(401);
}
@Test
void missingTokenReturns401() {
given()
.get("/api/v1/users/me")
.then()
.statusCode(401);
}
@Test
void fakeUserIdHeaderCannotAuthenticate() {
given()
.header("X-User-Id", UUID.randomUUID().toString())
.get("/api/v1/users/me")
.then()
.statusCode(401);
}
}
@@ -0,0 +1,73 @@
package com.vnp.demo;
import com.vnp.demo.dto.ChatCreateRequest;
import com.vnp.demo.models.ChatMember;
import com.vnp.demo.models.User;
import com.vnp.demo.repositories.ChatMemberRepository;
import com.vnp.demo.repositories.ChatRepository;
import com.vnp.demo.repositories.UserRepository;
import com.vnp.demo.service.ChatService;
import org.springframework.boot.test.mock.mockito.SpyBean;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
import java.util.UUID;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;
@SpringBootTest
class TransactionRollbackTest {
@Autowired
private ChatService chatService;
@Autowired
private ChatRepository chatRepository;
@Autowired
private UserRepository userRepository;
@SpyBean
private ChatMemberRepository chatMemberRepository;
@Test
void shouldRollbackChatCreationWhenMemberSaveFails() {
User user = userRepository.saveAndFlush(
new User(
"rollback_" + UUID.randomUUID()
.toString()
.substring(0, 8),
"Rollback Test",
"test-password-hash"
)
);
long chatsBefore = chatRepository.count();
doThrow(new IllegalStateException("Simulated failure"))
.when(chatMemberRepository)
.save(any(ChatMember.class));
ChatCreateRequest request = new ChatCreateRequest(
"Rollback test chat",
List.of(user.getId())
);
assertThrows(
IllegalStateException.class,
() -> chatService.create(user.getId(), request)
);
assertEquals(
chatsBefore,
chatRepository.count(),
"Chat must not be saved after transaction rollback"
);
}
}
@@ -0,0 +1,89 @@
BEGIN;
INSERT INTO users (
id,
username,
display_name,
password_hash
)
VALUES (
'11111111-1111-4111-8111-111111111111',
'benchmark_user',
'Benchmark User',
'benchmark-hash'
)
ON CONFLICT (id) DO NOTHING;
INSERT INTO chats (
id,
title
)
VALUES (
'22222222-2222-4222-8222-222222222222',
'Benchmark Chat'
)
ON CONFLICT (id) DO NOTHING;
INSERT INTO chat_members (
chat_id,
user_id
)
VALUES (
'22222222-2222-4222-8222-222222222222',
'11111111-1111-4111-8111-111111111111'
)
ON CONFLICT DO NOTHING;
INSERT INTO messages (
id,
chat_id,
sender_id,
text,
created_at
)
SELECT
(
'33333333-3333-4333-8333-' ||
lpad(g::text, 12, '0')
)::uuid,
'22222222-2222-4222-8222-222222222222'::uuid,
'11111111-1111-4111-8111-111111111111'::uuid,
'Benchmark message ' || g,
NOW() - INTERVAL '1 day'
+ g * INTERVAL '1 second'
FROM generate_series(1, 10000) AS g
ON CONFLICT (id) DO NOTHING;
COMMIT;
ANALYZE messages;
SELECT COUNT(*)
FROM messages
WHERE chat_id =
'22222222-2222-4222-8222-222222222222';
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id =
'22222222-2222-4222-8222-222222222222'
ORDER BY created_at, id
LIMIT 50;
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id =
'22222222-2222-4222-8222-222222222222'
AND (created_at, id) > (
(
SELECT created_at
FROM messages
WHERE id =
'33333333-3333-4333-8333-000000000050'
),
'33333333-3333-4333-8333-000000000050'::uuid
)
ORDER BY created_at, id
LIMIT 50;