Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
458 lines
37 KiB
Java
458 lines
37 KiB
Java
package ru.mtusi.messenger;
|
||
|
||
import jakarta.servlet.FilterChain;
|
||
import jakarta.servlet.ServletException;
|
||
import jakarta.servlet.http.*;
|
||
import org.springframework.boot.*;
|
||
import org.springframework.boot.autoconfigure.SpringBootApplication;
|
||
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
|
||
import org.springframework.boot.builder.SpringApplicationBuilder;
|
||
import org.springframework.context.ConfigurableApplicationContext;
|
||
import org.springframework.context.annotation.Bean;
|
||
import org.springframework.scheduling.annotation.EnableScheduling;
|
||
import com.fasterxml.jackson.databind.JsonNode;
|
||
import org.springframework.dao.DuplicateKeyException;
|
||
import org.springframework.dao.DataAccessException;
|
||
import org.springframework.data.redis.core.StringRedisTemplate;
|
||
import org.springframework.http.*;
|
||
import org.springframework.jdbc.core.JdbcTemplate;
|
||
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
|
||
import org.springframework.web.bind.annotation.*;
|
||
import org.springframework.web.filter.OncePerRequestFilter;
|
||
import org.springframework.transaction.annotation.Transactional;
|
||
import org.springframework.http.converter.HttpMessageNotReadableException;
|
||
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
|
||
import org.slf4j.LoggerFactory;
|
||
import com.fasterxml.jackson.databind.MapperFeature;
|
||
import java.io.IOException;
|
||
import java.nio.charset.StandardCharsets;
|
||
import java.security.MessageDigest;
|
||
import java.security.SecureRandom;
|
||
import java.time.*;
|
||
import java.util.*;
|
||
import java.util.Base64;
|
||
|
||
// Главная аннотация Spring Boot: включает запуск приложения и автоматическую настройку.
|
||
// @EnableScheduling запускает периодическую сверку БД и S3 (Reconciler) в API-репликах.
|
||
@SpringBootApplication
|
||
@EnableScheduling
|
||
public class MessengerApplication {
|
||
// Идентификатор экземпляра API = hostname контейнера (первые 12 символов ID контейнера в Docker).
|
||
// По нему scripts/stop-one.sh находит и останавливает нужную реплику.
|
||
private static final String INSTANCE_ID = System.getenv().getOrDefault("HOSTNAME", UUID.randomUUID().toString());
|
||
|
||
// Один образ — три режима: api (HTTP-сервер, по умолчанию), migrate (Flyway и выход)
|
||
// и reconcile (сверка БД и S3 и выход; аргументы см. Reconciler.cli).
|
||
public static void main(String[] args) throws IOException {
|
||
String mode = args.length > 0 ? args[0] : "api";
|
||
if (mode.equals("api")) {
|
||
SpringApplication.run(MessengerApplication.class, args);
|
||
return;
|
||
}
|
||
if (mode.equals("migrate")) {
|
||
// Только Flyway, без контекста Spring: контейнеру migration не нужны ни Redis, ни S3, ни их секреты.
|
||
String password = java.nio.file.Files.readString(java.nio.file.Path.of("/run/secrets/spring.datasource.password")).trim();
|
||
org.flywaydb.core.Flyway.configure().dataSource(System.getenv("SPRING_DATASOURCE_URL"), System.getenv("SPRING_DATASOURCE_USERNAME"), password).load().migrate();
|
||
return;
|
||
}
|
||
if (!mode.equals("reconcile")) {
|
||
System.err.println("usage: [api | migrate | reconcile [--apply] [--grace-seconds=N] [--verify-checksums]]");
|
||
System.exit(2);
|
||
}
|
||
ConfigurableApplicationContext ctx = new SpringApplicationBuilder(MessengerApplication.class)
|
||
.web(WebApplicationType.NONE)
|
||
.properties("reconcile.enabled=false", "spring.main.banner-mode=off", "logging.level.root=WARN")
|
||
.run();
|
||
int code;
|
||
try {
|
||
code = ctx.getBean(Reconciler.class).cli(Arrays.copyOfRange(args, 1, args.length));
|
||
} catch (Exception e) {
|
||
LoggerFactory.getLogger(MessengerApplication.class).error("reconcile failed", e);
|
||
code = 1;
|
||
}
|
||
int exit = code;
|
||
System.exit(SpringApplication.exit(ctx, () -> exit));
|
||
}
|
||
|
||
// @Bean регистрирует возвращаемый объект в контейнере Spring.
|
||
// BCrypt хранит пароль в виде хеша, поэтому исходный пароль не попадает в базу.
|
||
@Bean
|
||
BCryptPasswordEncoder passwordEncoder() {
|
||
// Возвращаем BCrypt-кодировщик, который Spring передаст контроллеру.
|
||
return new BCryptPasswordEncoder();
|
||
}
|
||
|
||
// Отключаем автоматическое превращение чисел в строки при чтении JSON.
|
||
@Bean
|
||
Jackson2ObjectMapperBuilderCustomizer strictJson() {
|
||
return builder -> builder.featuresToDisable(MapperFeature.ALLOW_COERCION_OF_SCALARS);
|
||
}
|
||
|
||
// @Bean регистрирует фильтр в контейнере Spring.
|
||
// Фильтр добавляет общий идентификатор каждому HTTP-ответу.
|
||
@Bean OncePerRequestFilter requestId() {
|
||
return new OncePerRequestFilter() {
|
||
// Метод фильтра вызывается для каждого HTTP-запроса.
|
||
protected void doFilterInternal(HttpServletRequest r, HttpServletResponse s, FilterChain c)
|
||
throws ServletException, IOException {
|
||
// Создаём уникальный идентификатор текущего запроса.
|
||
String id=UUID.randomUUID().toString();
|
||
// Добавляем идентификатор в HTTP-ответ.
|
||
s.setHeader("X-Request-Id", id);
|
||
// Добавляем стабильный идентификатор экземпляра API.
|
||
s.setHeader("X-Instance-Id", INSTANCE_ID);
|
||
// Сохраняем тот же идентификатор для обработчика ошибок.
|
||
r.setAttribute("requestId", id);
|
||
// Передаём запрос дальше по цепочке Spring.
|
||
c.doFilter(r, s);
|
||
}
|
||
};
|
||
}
|
||
|
||
// Эти record-классы описывают JSON-модели ответов и запросов.
|
||
// Публичная модель пользователя без пароля.
|
||
record User(UUID id, String username, String display_name, Instant created_at) {}
|
||
// Модель чата со списком участников.
|
||
record Chat(UUID id, String title, List<UUID> member_ids, Instant created_at) {}
|
||
// Модель сообщения с автором, временем создания и вложениями (в порядке из запроса).
|
||
record Message(UUID id, UUID chat_id, UUID sender_id, String text, Instant created_at, List<UUID> attachment_ids) {}
|
||
// Универсальная модель страницы списка.
|
||
record Page<T>(List<T> items, String next_cursor) {}
|
||
// Ответ успешного входа с Bearer-токеном.
|
||
record Session(String token, String token_type, Instant expires_at, User user) {}
|
||
// Тело запроса регистрации.
|
||
record UserIn(JsonNode username, JsonNode display_name, JsonNode password) {}
|
||
// Тело запроса создания чата.
|
||
record ChatIn(JsonNode title, List<UUID> member_ids) {}
|
||
// Тело запроса отправки сообщения; attachment_ids необязателен (по умолчанию []).
|
||
record MessageIn(JsonNode text, JsonNode attachment_ids) {}
|
||
// Поля внутренней ошибки API.
|
||
record Error(String code, String message, String request_id) {}
|
||
// Обёртка, требуемая форматом JSON ошибки.
|
||
record ErrorBody(Error error) {}
|
||
|
||
// Исключение хранит HTTP-статус и безопасный код ошибки.
|
||
static class ApiException extends RuntimeException {
|
||
// HTTP-статус, который будет отправлен клиенту.
|
||
final HttpStatus status;
|
||
// Короткий код ошибки для программы-клиента.
|
||
final String code;
|
||
ApiException(HttpStatus s, String c, String m) {
|
||
// Сохраняем текст сообщения в стандартном RuntimeException.
|
||
super(m);
|
||
status=s;
|
||
code=c;
|
||
}
|
||
}
|
||
|
||
// @RestController объединяет @Controller и @ResponseBody.
|
||
// Методы этого класса принимают HTTP-запросы и возвращают JSON.
|
||
@RestController
|
||
static class Api {
|
||
// JdbcTemplate работает с PostgreSQL, RedisTemplate — с Redis-сессиями.
|
||
// JdbcTemplate отправляет SQL-запросы в PostgreSQL.
|
||
final JdbcTemplate db;
|
||
// StringRedisTemplate работает со строковыми ключами Redis.
|
||
final StringRedisTemplate redis;
|
||
// BCryptPasswordEncoder проверяет и хеширует пароли.
|
||
final BCryptPasswordEncoder encoder;
|
||
// Генератор создаёт 32 случайных байта для каждой сессии.
|
||
final SecureRandom random = new SecureRandom();
|
||
// TTL можно уменьшить через переменную окружения для проверки expiry.
|
||
final long ttl = Long.parseLong(System.getenv().getOrDefault("SESSION_TTL_SECONDS", "3600"));
|
||
Api(JdbcTemplate d, StringRedisTemplate r, BCryptPasswordEncoder e) {
|
||
// Сохраняем зависимости, созданные Spring Boot.
|
||
db=d;
|
||
redis=r;
|
||
encoder=e;
|
||
}
|
||
// Метод проверяет доступность PostgreSQL тестовым запросом.
|
||
void dbOk() {
|
||
try {
|
||
// Простой запрос проверяет соединение с PostgreSQL.
|
||
db.queryForObject("select 1", Integer.class);
|
||
} catch (Exception e) {
|
||
// Внутреннюю ошибку базы не показываем клиенту.
|
||
throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","database is unavailable");
|
||
}
|
||
}
|
||
// Метод проверяет Bearer-токен и возвращает UUID пользователя.
|
||
UUID auth(HttpServletRequest req) {
|
||
// Читаем заголовок авторизации из HTTP-запроса.
|
||
String h=req.getHeader("Authorization");
|
||
// Защищённые методы принимают только Bearer-схему.
|
||
if (h==null || !h.startsWith("Bearer ")) throw unauth();
|
||
// В Redis хранится связь токена с UUID пользователя.
|
||
try { String v=redis.opsForValue().get("session:"+h.substring(7)); if(v==null) throw unauth(); return UUID.fromString(v); }
|
||
catch (ApiException e) { throw e; } catch (Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); }
|
||
}
|
||
ApiException unauth() { return new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","valid Bearer session required"); }
|
||
// Загружаем пользователя по UUID из PostgreSQL.
|
||
// Метод ищет пользователя в PostgreSQL по его UUID.
|
||
User user(UUID id) {
|
||
return db.query("select id,username,display_name,created_at from users where id=?", rs -> rs.next()
|
||
? new User(rs.getObject(1,UUID.class),rs.getString(2),rs.getString(3),rs.getTimestamp(4).toInstant()) : null, id);
|
||
}
|
||
// Метод проверяет, состоит ли пользователь в выбранном чате.
|
||
boolean member(UUID chat, UUID user) {
|
||
// Пользователь должен состоять в чате, иначе ресурс для него скрыт.
|
||
return Boolean.TRUE.equals(db.queryForObject("select exists(select 1 from chat_members where chat_id=? and user_id=?)",Boolean.class,chat,user));
|
||
}
|
||
// Загружает один чат и его участников напрямую по идентификатору.
|
||
Chat chatById(UUID id) {
|
||
return db.query("select id,title,created_at from chats where id=?",rs -> rs.next()
|
||
? new Chat(rs.getObject(1,UUID.class),rs.getString(2),
|
||
db.query("select user_id from chat_members where chat_id=?",(z,k)->z.getObject(1,UUID.class),id),
|
||
rs.getTimestamp(3).toInstant()) : null,id);
|
||
}
|
||
// Считает символы как Unicode code points, а не как UTF-16 char.
|
||
int codePointLength(String value) {
|
||
return value.codePointCount(0,value.length());
|
||
}
|
||
// Возвращает значение только если JSON-поле действительно является строкой.
|
||
String string(JsonNode value) { return value!=null && value.isTextual()?value.textValue():null; }
|
||
// PostgreSQL не хранит нулевой байт, поэтому заменяем его безопасным символом.
|
||
String databaseText(String value) { return value==null?null:value.replace('\0','\uFFFD'); }
|
||
// Проверяет обязательную непустую строку и её максимальную длину.
|
||
boolean text(String value, int max) { return value!=null && !value.isBlank() && codePointLength(value)<=max; }
|
||
// Предварительный SHA-256 сохраняет весь пароль перед ограниченным BCrypt.
|
||
String passwordValue(String value) {
|
||
try { return Base64.getEncoder().encodeToString(MessageDigest.getInstance("SHA-256").digest(value.getBytes(StandardCharsets.UTF_8))); }
|
||
catch (Exception e) { throw new IllegalStateException("password hashing is unavailable",e); }
|
||
}
|
||
|
||
// Готовность проверяет не только Java-процесс, но и его зависимости.
|
||
// @GetMapping связывает GET-запрос с Java-методом.
|
||
@GetMapping({"/health/live","/health/ready"})
|
||
// Для ready дополнительно проверяем PostgreSQL и Redis.
|
||
// Метод возвращает JSON со статусом приложения.
|
||
Map<String,String> health(HttpServletRequest r) { if (r.getRequestURI().endsWith("ready")) { dbOk(); try { redis.hasKey("health"); } catch(Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); } } return Map.of("status","ok"); }
|
||
// @PostMapping связывает POST-запрос с методом регистрации.
|
||
@PostMapping("/api/v1/users")
|
||
// @RequestBody преобразует JSON-тело запроса в объект UserIn.
|
||
ResponseEntity<User> register(@RequestBody UserIn in) {
|
||
String username=in==null?null:string(in.username());
|
||
String displayName=in==null?null:string(in.display_name());
|
||
String password=in==null?null:string(in.password());
|
||
// До запроса в базу проверяем формат обязательных полей.
|
||
if(username==null || !username.matches("[a-z0-9_]{3,32}") || !text(displayName,100) || password==null || password.isBlank() || codePointLength(password)<12 || codePointLength(password)>128) bad();
|
||
displayName=databaseText(displayName);
|
||
// Создаём UUID пользователя и фиксируем время регистрации.
|
||
UUID id=UUID.randomUUID(); Instant now=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.MICROS);
|
||
// Значения передаются параметрами, а не склеиваются со строкой SQL.
|
||
try { db.update("insert into users values(?,?,?,?,?)",id,username,displayName,encoder.encode(passwordValue(password)),java.sql.Timestamp.from(now)); }
|
||
// Уникальное ограничение username превращаем в понятный ответ 409.
|
||
catch(DuplicateKeyException e) { throw new ApiException(HttpStatus.CONFLICT,"conflict","username is already used"); }
|
||
// Возвращаем созданного пользователя без пароля.
|
||
return ResponseEntity.status(201).body(new User(id,username,displayName,now));
|
||
}
|
||
// POST-метод входа проверяет Basic-логин и создаёт Bearer-сессию.
|
||
@PostMapping("/api/v1/auth/sessions")
|
||
// HttpServletRequest позволяет прочитать заголовок Authorization.
|
||
ResponseEntity<Session> login(HttpServletRequest req) {
|
||
// Читаем Basic-заголовок, который используется только при входе.
|
||
String h=req.getHeader("Authorization");
|
||
if(h==null || !h.startsWith("Basic ")) { HttpHeaders x=new HttpHeaders(); x.set("WWW-Authenticate","Basic realm=\"messenger\", charset=\"UTF-8\""); throw new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","Basic authentication required"); }
|
||
// Basic используется только для входа, после него клиент получает Bearer-токен.
|
||
String[] p; try { p=new String(Base64.getDecoder().decode(h.substring(6)),StandardCharsets.UTF_8).split(":",2); } catch(Exception e) { p=new String[0]; }
|
||
// Получаем BCrypt-хеш пользователя из PostgreSQL.
|
||
String hash=p.length==2 ? db.query("select password_hash from users where username=?",rs -> rs.next()?rs.getString(1):null,p[0]) : null;
|
||
// Сравниваем введённый пароль с сохранённым хешем.
|
||
if(p.length!=2 || hash==null || codePointLength(p[1])<12 || codePointLength(p[1])>128 || !encoder.matches(passwordValue(p[1]),hash)) { HttpHeaders x=new HttpHeaders(); x.set("WWW-Authenticate","Basic realm=\"messenger\", charset=\"UTF-8\""); throw new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","invalid credentials"); }
|
||
// После успешной проверки загружаем полную модель пользователя.
|
||
User u=user(db.queryForObject("select id from users where username=?",UUID.class,p[0]));
|
||
// Генерируем непрозрачный случайный токен сессии.
|
||
byte[] secret=new byte[32]; random.nextBytes(secret);
|
||
String token=Base64.getUrlEncoder().withoutPadding().encodeToString(secret);
|
||
// Вычисляем момент, когда сессия перестанет действовать.
|
||
Instant exp=Instant.now().plusSeconds(ttl);
|
||
// Сессия автоматически удалится из Redis после окончания TTL.
|
||
try { redis.opsForValue().set("session:"+token,u.id().toString(),Duration.ofSeconds(ttl)); } catch(Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); }
|
||
return ResponseEntity.status(201).body(new Session(token,"Bearer",exp,u));
|
||
}
|
||
// @DeleteMapping связывает DELETE-запрос с удалением сессии.
|
||
// Logout сразу удаляет текущий токен из Redis.
|
||
@DeleteMapping("/api/v1/auth/sessions/current") ResponseEntity<Void> logout(HttpServletRequest r) { auth(r); redis.delete("session:"+r.getHeader("Authorization").substring(7)); return ResponseEntity.noContent().build(); }
|
||
// GET-запрос возвращает данные текущего авторизованного пользователя.
|
||
@GetMapping("/api/v1/users/me") User me(HttpServletRequest r) { return user(auth(r)); }
|
||
// @Transactional объединяет несколько SQL-команд в одну транзакцию.
|
||
// Если одна команда завершится ошибкой, изменения откатываются.
|
||
// Вставка чата и всех его участников выполняется как одна транзакция.
|
||
@Transactional
|
||
// POST-запрос создаёт новый чат.
|
||
@PostMapping("/api/v1/chats") ResponseEntity<Chat> createChat(@RequestBody ChatIn in,HttpServletRequest r) {
|
||
// Владелец чата определяется по Bearer-сессии.
|
||
String title=in==null?null:string(in.title());
|
||
UUID owner=auth(r); if(!text(title,100)||in.member_ids()==null||in.member_ids().isEmpty()||in.member_ids().size()>100||new HashSet<>(in.member_ids()).size()!=in.member_ids().size()||!in.member_ids().contains(owner)) bad();
|
||
// Проверяем существование каждого участника.
|
||
for(UUID id:in.member_ids()) if(user(id)==null) bad();
|
||
// ID и время создаются сервером. PostgreSQL хранит микросекунды, поэтому ответ POST совпадает с GET.
|
||
UUID id=UUID.randomUUID(); Instant now=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.MICROS);
|
||
// Записываем чат и участников в одной транзакции.
|
||
title=databaseText(title);
|
||
db.update("insert into chats values(?,?,?)",id,title,java.sql.Timestamp.from(now)); for(UUID m:in.member_ids()) db.update("insert into chat_members values(?,?)",id,m);
|
||
// Возвращаем созданную модель чата.
|
||
return ResponseEntity.status(201).body(new Chat(id,title,in.member_ids(),now));
|
||
}
|
||
// GET-запрос получает список чатов текущего пользователя.
|
||
@GetMapping("/api/v1/chats")
|
||
Page<Chat> chats(HttpServletRequest r) {
|
||
// Определяем пользователя, для которого строится список.
|
||
UUID u=auth(r);
|
||
String cursor=r.getParameter("cursor");
|
||
int limit=parseLimit(r.getParameter("limit"));
|
||
// Запрашиваем только чаты, где пользователь является участником.
|
||
String sql="select c.id,c.title,c.created_at from chats c join chat_members m on m.chat_id=c.id where m.user_id=? ";
|
||
List<Object> args=new ArrayList<>(List.of(u));
|
||
if(cursor!=null) {
|
||
try {
|
||
String[] p=new String(Base64.getUrlDecoder().decode(cursor),StandardCharsets.UTF_8).split("\\|",-1);
|
||
if(p.length!=2) bad();
|
||
sql+="and (c.created_at,c.id)>(?,?) ";
|
||
args.add(java.sql.Timestamp.from(OffsetDateTime.parse(p[0]).toInstant()));
|
||
args.add(UUID.fromString(p[1]));
|
||
} catch(Exception e) { if(e instanceof ApiException a) throw a; bad(); }
|
||
}
|
||
sql+="order by c.created_at,c.id limit ?";
|
||
args.add(limit+1);
|
||
List<Chat> x=db.query(sql,(rs,n)->new Chat(rs.getObject(1,UUID.class),rs.getString(2),db.query("select user_id from chat_members where chat_id=?", (z,k)->z.getObject(1,UUID.class),rs.getObject(1)),rs.getTimestamp(3).toInstant()),args.toArray());
|
||
String next=x.size()>limit?Base64.getUrlEncoder().withoutPadding().encodeToString((x.get(limit-1).created_at()+"|"+x.get(limit-1).id()).getBytes(StandardCharsets.UTF_8)):null;
|
||
return new Page<>(x.subList(0,Math.min(limit,x.size())),next);
|
||
}
|
||
// {id} является переменной частью URL.
|
||
@GetMapping("/api/v1/chats/{id}")
|
||
// @PathVariable получает id из адреса запроса.
|
||
Chat chat(@PathVariable UUID id,HttpServletRequest r) {
|
||
// Сначала проверяем токен и членство в чате.
|
||
UUID u=auth(r); if(!member(id,u)) throw notFound();
|
||
// Загружаем чат напрямую, поэтому поздние записи не зависят от первой страницы списка.
|
||
Chat result=chatById(id);
|
||
if(result==null) throw notFound();
|
||
return result;
|
||
}
|
||
// POST-запрос добавляет сообщение в выбранный чат.
|
||
// @PathVariable получает id чата, а @RequestBody — текст из JSON.
|
||
@Transactional
|
||
@PostMapping("/api/v1/chats/{id}/messages") ResponseEntity<Message> message(@PathVariable UUID id,@RequestBody MessageIn in,HttpServletRequest r) {
|
||
// Автор сообщения берётся из сессии, а не из тела запроса.
|
||
String messageText=databaseText(in==null?null:string(in.text()));
|
||
UUID u=auth(r); if(!member(id,u)) throw notFound();
|
||
List<UUID> attachments=attachmentIds(in==null?null:in.attachment_ids());
|
||
// Пустой текст допустим только с вложением; непустой не может состоять из одних пробелов.
|
||
if(messageText==null || codePointLength(messageText)>4000 || (messageText.isEmpty()?attachments.isEmpty():messageText.isBlank())) bad();
|
||
// Проверяем обязательный Idempotency-Key.
|
||
String key=r.getHeader("Idempotency-Key");
|
||
if(key==null || !key.matches("[A-Za-z0-9._:-]{1,128}")) throw new ApiException(HttpStatus.BAD_REQUEST,"invalid_request","valid Idempotency-Key required");
|
||
// Все вложения должны быть готовыми вложениями этого чата; чужое или неизвестное — 404.
|
||
if(!attachments.isEmpty() && db.queryForObject("select count(*) from attachments where chat_id=? and state='ready' and id=any(?)",Integer.class,id,attachments.toArray(new UUID[0]))!=attachments.size()) throw notFound();
|
||
// Хеш тела для повторов с тем же ключом: отсутствующий attachment_ids и [] дают одно значение.
|
||
String bodyHash;
|
||
try { bodyHash=Base64.getEncoder().encodeToString(MessageDigest.getInstance("SHA-256").digest((messageText+"\0"+attachments).getBytes(StandardCharsets.UTF_8))); }
|
||
catch(Exception e) { throw new IllegalStateException("hash unavailable",e); }
|
||
// Сервер создаёт ID и время сообщения.
|
||
UUID mid=UUID.randomUUID(); Instant now=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.MICROS);
|
||
// Сначала занимаем ключ. При одновременном повторе через другую реплику PostgreSQL ждёт
|
||
// её транзакцию, а ON CONFLICT DO NOTHING не обрывает нашу транзакцию ошибкой (иначе был бы 503).
|
||
if(db.update("insert into idempotency_keys values(?,?,?,?,?,?) on conflict do nothing",key,u,id,bodyHash,mid,java.sql.Timestamp.from(now))==0) {
|
||
// Ключ уже занят: тот же body — возвращаем созданное сообщение, другой body — 409.
|
||
UUID existingId=db.query("select message_id,request_hash from idempotency_keys where user_id=? and chat_id=? and idempotency_key=?",rs -> {
|
||
if(rs.next()) {
|
||
if(!bodyHash.equals(rs.getString(2))) throw new ApiException(HttpStatus.CONFLICT,"conflict","different body with same idempotency key");
|
||
return rs.getObject(1,UUID.class);
|
||
}
|
||
return null;
|
||
},u,id,key);
|
||
Message existing=db.queryForObject(MESSAGE_SELECT+"where m.id=?",this::messageRow,existingId);
|
||
return ResponseEntity.status(201).body(existing);
|
||
}
|
||
// Сообщение и его вложения пишутся в той же транзакции, что и ключ: появится всё или ничего.
|
||
db.update("insert into messages values(?,?,?,?,?)",mid,id,u,messageText,java.sql.Timestamp.from(now));
|
||
for(int i=0;i<attachments.size();i++) db.update("insert into message_attachments values(?,?,?)",mid,attachments.get(i),i);
|
||
return ResponseEntity.status(201).body(new Message(mid,id,u,messageText,now,attachments));
|
||
}
|
||
// Колонки сообщения; attachment_ids собираются из message_attachments в порядке отправки.
|
||
static final String MESSAGE_SELECT="select m.id,m.chat_id,m.sender_id,m.text,m.created_at,"
|
||
+"coalesce((select array_agg(x.attachment_id order by x.position) from message_attachments x where x.message_id=m.id),'{}') from messages m ";
|
||
Message messageRow(java.sql.ResultSet rs,int n) throws java.sql.SQLException {
|
||
return new Message(rs.getObject(1,UUID.class),rs.getObject(2,UUID.class),rs.getObject(3,UUID.class),rs.getString(4),rs.getTimestamp(5).toInstant(),List.of((UUID[])rs.getArray(6).getArray()));
|
||
}
|
||
// attachment_ids: отсутствует — []; иначе массив 0–10 уникальных UUID в каноническом виде.
|
||
List<UUID> attachmentIds(JsonNode value) {
|
||
if(value==null) return List.of();
|
||
if(!value.isArray() || value.size()>10) bad();
|
||
List<UUID> ids=new ArrayList<>();
|
||
for(JsonNode x:value) {
|
||
String s=x.isTextual()?x.textValue():"";
|
||
try { UUID id=UUID.fromString(s); if(!id.toString().equalsIgnoreCase(s)) bad(); ids.add(id); } catch(IllegalArgumentException e) { bad(); }
|
||
}
|
||
if(new HashSet<>(ids).size()!=ids.size()) bad();
|
||
return ids;
|
||
}
|
||
// GET-запрос возвращает историю сообщений с cursor-пагинацией.
|
||
// @RequestParam получает limit и cursor из параметров URL.
|
||
@GetMapping("/api/v1/chats/{id}/messages") Page<Message> messages(@PathVariable UUID id,@RequestParam(required=false) String limit,@RequestParam(required=false) String cursor,HttpServletRequest r) {
|
||
// Историю может читать только участник чата.
|
||
UUID u=auth(r); if(!member(id,u)) throw notFound(); int pageLimit=parseLimit(limit);
|
||
// Начинаем параметризованный запрос истории.
|
||
String sql=MESSAGE_SELECT+"where m.chat_id=? ";
|
||
// Список параметров передаётся в JdbcTemplate отдельно от SQL.
|
||
List<Object> args=new ArrayList<>(List.of(id));
|
||
if(cursor!=null) {
|
||
try {
|
||
// Cursor хранит время и ID последнего сообщения предыдущей страницы.
|
||
// Декодируем cursor из Base64 в обычную строку.
|
||
String[] p=new String(Base64.getUrlDecoder().decode(cursor),StandardCharsets.UTF_8).split("\\|",-1);
|
||
if(p.length!=3 || !id.equals(UUID.fromString(p[0]))) bad();
|
||
// Добавляем условие keyset-пагинации после последнего сообщения.
|
||
sql+="and (m.created_at,m.id)>(?,?) "; args.add(java.sql.Timestamp.from(OffsetDateTime.parse(p[1]).toInstant())); args.add(UUID.fromString(p[2]));
|
||
} catch(Exception e) { bad(); }
|
||
}
|
||
// Сортируем историю и берём одну запись сверх лимита для следующего cursor.
|
||
sql+="order by m.created_at,m.id limit ?"; args.add(pageLimit+1);
|
||
// Выполняем запрос и превращаем строки базы в объекты Message.
|
||
List<Message> x=db.query(sql,this::messageRow,args.toArray());
|
||
// Если запись сверх лимита есть, кодируем её позицию как следующий cursor.
|
||
String next=x.size()>pageLimit?Base64.getUrlEncoder().withoutPadding().encodeToString((id+"|"+x.get(pageLimit-1).created_at()+"|"+x.get(pageLimit-1).id()).getBytes(StandardCharsets.UTF_8)):null; return new Page<>(x.subList(0,Math.min(pageLimit,x.size())),next);
|
||
}
|
||
// Преобразует limit списка чатов в число и проверяет диапазон.
|
||
int parseLimit(String value) { try { int limit=value==null?50:Integer.parseInt(value); if(limit<1||limit>100) bad(); return limit; } catch(NumberFormatException e) { bad(); return 0; } }
|
||
// Формируем ошибку, не раскрывая наличие чужого объекта.
|
||
ApiException notFound(){return new ApiException(HttpStatus.NOT_FOUND,"not_found","object not found");}
|
||
// Формируем общую ошибку некорректного запроса.
|
||
void bad(){throw new ApiException(HttpStatus.BAD_REQUEST,"invalid_request","invalid request");}
|
||
}
|
||
// @RestControllerAdvice применяет обработчики ко всем REST-контроллерам.
|
||
// Благодаря этому ошибки возвращаются в одном формате JSON.
|
||
@RestControllerAdvice static class Errors {
|
||
// Все ошибки API приводятся к одному JSON-формату.
|
||
// @ExceptionHandler связывает тип исключения с методом обработки.
|
||
// Здесь обрабатываются специально созданные ошибки API.
|
||
@ExceptionHandler(ApiException.class) ResponseEntity<ErrorBody> api(ApiException e,HttpServletRequest r){
|
||
// Создаём заголовки ответа с ошибкой.
|
||
HttpHeaders h=new HttpHeaders();
|
||
if(e.status==HttpStatus.UNAUTHORIZED) h.set("WWW-Authenticate",r.getRequestURI().equals("/api/v1/auth/sessions")?"Basic realm=\"messenger\", charset=\"UTF-8\"":"Bearer realm=\"messenger\"");
|
||
// Возвращаем статус, заголовки и единое тело ошибки.
|
||
return ResponseEntity.status(e.status).headers(h).body(new ErrorBody(new Error(e.code,e.getMessage(),id(r))));
|
||
}
|
||
// Неожиданные исключения превращаем в безопасный ответ 500.
|
||
// Этот обработчик является запасным для неожиданных исключений.
|
||
@ExceptionHandler(Exception.class) ResponseEntity<ErrorBody> other(Exception e,HttpServletRequest r){
|
||
// Ошибки самого Spring MVC (неизвестный путь, метод, Content-Type) сохраняют свой 4xx, а не становятся 500.
|
||
if(e instanceof org.springframework.web.ErrorResponse x && x.getStatusCode().is4xxClientError()) {
|
||
int s=x.getStatusCode().value();
|
||
Error err=s==404?new Error("not_found","object not found",id(r)):s==415?new Error("unsupported_media_type","unsupported media type",id(r)):new Error("invalid_request","invalid request",id(r));
|
||
return ResponseEntity.status(s).headers(x.getHeaders()).body(new ErrorBody(err));
|
||
}
|
||
LoggerFactory.getLogger(Errors.class).error("request failed",e); return ResponseEntity.status(500).body(new ErrorBody(new Error("internal_error","internal server error",id(r)))); }
|
||
// Неправильный JSON считается ошибкой входных данных клиента.
|
||
// Этот обработчик ловит неправильный или повреждённый JSON.
|
||
@ExceptionHandler(HttpMessageNotReadableException.class) ResponseEntity<ErrorBody> malformed(HttpServletRequest r){ return ResponseEntity.badRequest().body(new ErrorBody(new Error("invalid_request","invalid request",id(r)))); }
|
||
// Ошибка преобразования UUID или числового параметра означает неверный запрос.
|
||
@ExceptionHandler(MethodArgumentTypeMismatchException.class) ResponseEntity<ErrorBody> mismatch(HttpServletRequest r){ return ResponseEntity.badRequest().body(new ErrorBody(new Error("invalid_request","invalid request",id(r)))); }
|
||
// Ошибка PostgreSQL возвращается как временная недоступность зависимости.
|
||
@ExceptionHandler(DataAccessException.class) ResponseEntity<ErrorBody> database(DataAccessException e,HttpServletRequest r){ return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body(new ErrorBody(new Error("unavailable","database is unavailable",id(r)))); }
|
||
// Получаем ID запроса, который добавил фильтр.
|
||
String id(HttpServletRequest r){ return String.valueOf(r.getAttribute("requestId")); }
|
||
}
|
||
}
|