Files
mtusi2026lab3/src/main/java/ru/mtusi/lab3/MessengerServer.java
T

626 lines
27 KiB
Java

package ru.mtusi.lab3;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.StreamReadFeature;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.json.JsonMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;
import org.mindrot.jbcrypt.BCrypt;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Base64;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.security.SecureRandom;
import java.security.MessageDigest;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Consumer;
import java.util.regex.Pattern;
final class MessengerServer {
private static final int MAX_BODY = 64 * 1024;
private static final Pattern USERNAME = Pattern.compile("^[a-z0-9_]{3,32}$");
private static final Pattern UUID_TEXT = Pattern.compile(
"(?i)[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}");
private static final JsonMapper JSON = JsonMapper.builder()
.enable(StreamReadFeature.STRICT_DUPLICATE_DETECTION)
.build();
private final HttpServer http;
private final DatabaseStore store = new DatabaseStore();
private final SecureRandom random = new SecureRandom();
private final long sessionTtlSeconds = Long.parseLong(System.getenv().getOrDefault("SESSION_TTL_SECONDS", "3600"));
private final AtomicBoolean accepting = new AtomicBoolean(true);
private final AtomicBoolean stopped = new AtomicBoolean(false);
private final Consumer<String> info;
private final Consumer<String> error;
private final int port;
private final String instanceId = System.getenv().getOrDefault("INSTANCE_ID", UUID.randomUUID().toString());
private MessengerServer(String host, int port, Consumer<String> info, Consumer<String> error) throws IOException {
this.info = info;
this.error = error;
this.http = HttpServer.create(new InetSocketAddress(host, port), 128);
this.port = http.getAddress().getPort();
ExecutorService pool = Executors.newFixedThreadPool(64, runnable -> {
Thread thread = new Thread(runnable, "http");
thread.setDaemon(true);
return thread;
});
http.setExecutor(pool);
http.createContext("/", this::handle);
http.start();
}
static MessengerServer start(String host, int port, Consumer<String> info, Consumer<String> error) throws IOException {
return new MessengerServer(host, port, info, error);
}
int port() {
return port;
}
void refuseNewRequests() {
accepting.set(false);
}
void stop() {
accepting.set(false);
if (stopped.compareAndSet(false, true)) {
http.stop(2);
}
}
private void handle(HttpExchange exchange) {
long started = System.nanoTime();
String requestId = UUID.randomUUID().toString();
String method = exchange.getRequestMethod();
String path = exchange.getRequestURI().getPath() == null ? "" : exchange.getRequestURI().getPath();
int status = 500;
try {
status = dispatch(exchange, requestId, method, path);
} catch (ApiException exception) {
status = writeError(exchange, requestId, exception);
} catch (Exception exception) {
error.accept("event=unexpected type=" + exception.getClass().getName() + " message=" + exception.getMessage());
status = writeError(exchange, requestId, ApiException.internalError());
} finally {
long durationMs = (System.nanoTime() - started) / 1_000_000L;
info.accept("request_id=" + requestId
+ " method=" + method
+ " path=" + path
+ " status=" + status
+ " duration_ms=" + durationMs);
exchange.close();
}
}
private int dispatch(HttpExchange exchange, String requestId, String method, String path) throws IOException {
if (!accepting.get()) {
if ("GET".equals(method) && "/health/live".equals(path)) {
return writeJson(exchange, requestId, 200, health());
}
throw ApiException.unavailable();
}
if ("GET".equals(method) && "/health/live".equals(path)) {
rejectQuery(exchange);
return writeJson(exchange, requestId, 200, health());
}
if ("GET".equals(method) && "/health/ready".equals(path)) {
rejectQuery(exchange);
return writeJson(exchange, requestId, 200, health());
}
if ("POST".equals(method) && "/api/v1/users".equals(path)) {
rejectQuery(exchange);
JsonNode body = readObject(readBody(exchange));
allowOnly(body, "username", "display_name", "password");
String username = requiredText(body, "username");
if (!USERNAME.matcher(username).matches()) {
throw ApiException.invalid("Недопустимый username");
}
String displayName = requiredText(body, "display_name");
requireCodePoints(displayName, 1, 100, "display_name");
String password = requiredText(body, "password");
requireCodePoints(password, 12, 128, "password");
User user = store.createUser(username, displayName, BCrypt.hashpw(password, BCrypt.gensalt(12)));
return writeJson(exchange, requestId, 201, userJson(user));
}
if ("POST".equals(method) && "/api/v1/auth/sessions".equals(path)) {
rejectQuery(exchange);
String[] credentials = basicCredentials(exchange);
DatabaseStore.Credential credential = store.credential(credentials[0]).orElseThrow(ApiException::unauthorized);
if (!BCrypt.checkpw(credentials[1], credential.passwordHash())) throw ApiException.unauthorized();
Instant expires = Instant.now().plusSeconds(sessionTtlSeconds);
byte[] tokenBytes = new byte[32];
random.nextBytes(tokenBytes);
String token = Base64.getUrlEncoder().withoutPadding().encodeToString(tokenBytes);
store.createSession(credential.user().id(), token, expires);
ObjectNode result = JSON.createObjectNode().put("token", token).put("token_type", "Bearer")
.put("expires_at", DateTimeFormatter.ISO_INSTANT.format(expires));
result.set("user", userJson(credential.user()));
return writeJson(exchange, requestId, 201, result, null);
}
if ("DELETE".equals(method) && "/api/v1/auth/sessions/current".equals(path)) {
String token = bearerToken(exchange);
if (store.session(token).isEmpty()) throw ApiException.unauthorized();
store.revoke(token);
exchange.getResponseHeaders().set("X-Request-Id", requestId);
exchange.getResponseHeaders().set("X-Instance-Id", instanceId);
exchange.sendResponseHeaders(204, -1);
return 204;
}
if ("GET".equals(method) && "/api/v1/users/me".equals(path)) {
rejectQuery(exchange);
User user = requireUser(exchange);
return writeJson(exchange, requestId, 200, userJson(user));
}
if ("POST".equals(method) && "/api/v1/chats".equals(path)) {
rejectQuery(exchange);
User user = requireUser(exchange);
JsonNode body = readObject(readBody(exchange));
allowOnly(body, "title", "member_ids");
String title = requiredText(body, "title");
requireCodePoints(title, 1, 100, "title");
List<UUID> members = memberIds(body);
Chat chat = store.createChat(user.id(), title, members);
return writeJson(exchange, requestId, 201, chatJson(chat));
}
if ("GET".equals(method) && "/api/v1/chats".equals(path)) {
User user = requireUser(exchange);
Query query = pagingQuery(exchange);
List<Chat> chats = new ArrayList<>(store.chatsOf(user.id()));
chats.sort(Comparator.comparing(Chat::createdAt).thenComparing(Chat::id));
return writePage(exchange, requestId, chats, query, "c", user.id(), Chat::createdAt, Chat::id, MessengerServer::chatJson);
}
ChatRoute chatRoute = matchChat(path);
if (chatRoute != null && "GET".equals(method) && chatRoute.messages) {
User user = requireUser(exchange);
UUID chatId = parsePathUuid(chatRoute.idText);
Query query = pagingQuery(exchange);
List<Message> messages = new ArrayList<>(store.messagesOf(user.id(), chatId));
messages.sort(Comparator.comparing(Message::createdAt).thenComparing(Message::id));
return writePage(exchange, requestId, messages, query, "m", chatId, Message::createdAt, Message::id, this::messageJson);
}
if (chatRoute != null && "POST".equals(method) && chatRoute.messages) {
rejectQuery(exchange);
User user = requireUser(exchange);
UUID chatId = parsePathUuid(chatRoute.idText);
JsonNode body = readObject(readBody(exchange));
allowOnly(body, "text");
String key = exchange.getRequestHeaders().getFirst("Idempotency-Key");
if (key == null || !key.matches("[A-Za-z0-9._:-]{1,128}")) throw ApiException.invalid("Некорректный Idempotency-Key");
String text = requiredText(body, "text");
requireCodePoints(text, 1, 4000, "text");
String hash = sha256(text);
Message message = store.idempotentMessage(user.id(), chatId, key, hash)
.orElseGet(() -> store.addIdempotentMessage(user.id(), chatId, key, hash, text));
return writeJson(exchange, requestId, 201, messageJson(message));
}
if (chatRoute != null && "GET".equals(method)) {
rejectQuery(exchange);
User user = requireUser(exchange);
UUID chatId = parsePathUuid(chatRoute.idText);
Chat chat = store.visibleChat(user.id(), chatId).orElseThrow(ApiException::notFound);
return writeJson(exchange, requestId, 200, chatJson(chat));
}
throw ApiException.notFound();
}
private User requireUser(HttpExchange exchange) {
return store.session(bearerToken(exchange)).map(Session::user).orElseThrow(ApiException::unauthorized);
}
private String bearerToken(HttpExchange exchange) {
String header = exchange.getRequestHeaders().getFirst("Authorization");
if (header == null || !header.regionMatches(true, 0, "Bearer ", 0, 7) || header.length() <= 7) {
throw ApiException.unauthorized();
}
return header.substring(7).trim();
}
private static String[] basicCredentials(HttpExchange exchange) {
String header = exchange.getRequestHeaders().getFirst("Authorization");
if (header == null || !header.regionMatches(true, 0, "Basic ", 0, 6)) throw ApiException.unauthorized();
try {
String decoded = new String(Base64.getDecoder().decode(header.substring(6).trim()), StandardCharsets.UTF_8);
int colon = decoded.indexOf(':');
if (colon < 1) throw new IllegalArgumentException();
return new String[]{decoded.substring(0, colon), decoded.substring(colon + 1)};
} catch (IllegalArgumentException e) { throw ApiException.unauthorized(); }
}
private static UUID parsePathUuid(String raw) {
if (!UUID_TEXT.matcher(raw).matches()) {
throw ApiException.invalid("Некорректный идентификатор");
}
return UUID.fromString(raw);
}
private static ChatRoute matchChat(String path) {
String prefix = "/api/v1/chats/";
if (!path.startsWith(prefix)) {
return null;
}
String rest = path.substring(prefix.length());
if (rest.isEmpty() || rest.indexOf('/') == 0) {
return null;
}
int slash = rest.indexOf('/');
if (slash < 0) {
return new ChatRoute(rest, false);
}
if (rest.substring(slash).equals("/messages")) {
return new ChatRoute(rest.substring(0, slash), true);
}
return null;
}
private byte[] readBody(HttpExchange exchange) throws IOException {
String contentType = exchange.getRequestHeaders().getFirst("Content-Type");
if (contentType == null) {
throw ApiException.invalid("Ожидался Content-Type application/json");
}
String mime = contentType.split(";", 2)[0].trim().toLowerCase(Locale.ROOT);
if (!mime.equals("application/json")) {
throw ApiException.invalid("Ожидался Content-Type application/json");
}
return readLimited(exchange.getRequestBody());
}
private static byte[] readLimited(InputStream input) throws IOException {
ByteArrayOutputStream output = new ByteArrayOutputStream();
byte[] buffer = new byte[4096];
int total = 0;
int read;
while ((read = input.read(buffer)) >= 0) {
total += read;
if (total > MAX_BODY) {
throw ApiException.tooLarge();
}
output.write(buffer, 0, read);
}
return output.toByteArray();
}
private static JsonNode readObject(byte[] bytes) {
if (bytes.length == 0) {
throw ApiException.invalid("Пустое тело запроса");
}
try (JsonParser parser = JSON.createParser(bytes)) {
JsonNode node = JSON.readTree(parser);
if (parser.nextToken() != null) {
throw ApiException.invalid("Некорректный JSON");
}
if (node == null || !node.isObject()) {
throw ApiException.invalid("Ожидался JSON-объект");
}
return node;
} catch (ApiException exception) {
throw exception;
} catch (Exception exception) {
throw ApiException.invalid("Некорректный JSON");
}
}
private static void allowOnly(JsonNode object, String... fields) {
Set<String> allowed = Set.of(fields);
object.fieldNames().forEachRemaining(name -> {
if (!allowed.contains(name)) {
throw ApiException.invalid("В запросе есть лишние поля");
}
});
}
private static String requiredText(JsonNode object, String field) {
if (!object.has(field) || object.get(field).isNull()) {
throw ApiException.invalid("Отсутствует поле " + field);
}
JsonNode node = object.get(field);
if (!node.isTextual()) {
throw ApiException.invalid("Поле " + field + " должно быть строкой");
}
return node.textValue();
}
private static void requireCodePoints(String value, int min, int max, String field) {
int count = value.codePointCount(0, value.length());
if (count < min || count > max || isBlank(value)) {
throw ApiException.invalid("Недопустимое значение " + field);
}
}
private static boolean isBlank(String value) {
return value.codePoints().allMatch(MessengerServer::isUnicodeWhiteSpace);
}
// Unicode White_Space. Character.isWhitespace пропускает U+0085 (NEL).
private static boolean isUnicodeWhiteSpace(int codePoint) {
return switch (codePoint) {
case 0x0009, 0x000A, 0x000B, 0x000C, 0x000D,
0x0020, 0x0085, 0x00A0, 0x1680,
0x2028, 0x2029, 0x202F, 0x205F, 0x3000 -> true;
default -> codePoint >= 0x2000 && codePoint <= 0x200A;
};
}
private static List<UUID> memberIds(JsonNode object) {
if (!object.has("member_ids") || !object.get("member_ids").isArray()) {
throw ApiException.invalid("Поле member_ids должно быть массивом");
}
ArrayNode array = (ArrayNode) object.get("member_ids");
if (array.size() < 1 || array.size() > 100) {
throw ApiException.invalid("Недопустимое число участников");
}
List<UUID> ids = new ArrayList<>();
for (JsonNode item : array) {
if (!item.isTextual() || !UUID_TEXT.matcher(item.textValue()).matches()) {
throw ApiException.invalid("Некорректный идентификатор участника");
}
UUID id = UUID.fromString(item.textValue());
if (ids.contains(id)) {
throw ApiException.invalid("Повторяющийся участник");
}
ids.add(id);
}
return ids;
}
private static void rejectQuery(HttpExchange exchange) {
String raw = exchange.getRequestURI().getRawQuery();
if (raw != null && !raw.isEmpty()) {
throw ApiException.invalid("Неподдерживаемые параметры запроса");
}
}
private static Query pagingQuery(HttpExchange exchange) {
String raw = exchange.getRequestURI().getRawQuery();
if (raw == null || raw.isEmpty()) {
return new Query(null, null);
}
Map<String, List<String>> params = new LinkedHashMap<>();
for (String part : raw.split("&", -1)) {
if (part.isEmpty()) {
continue;
}
int eq = part.indexOf('=');
String key = decode(eq < 0 ? part : part.substring(0, eq));
String value = decode(eq < 0 ? "" : part.substring(eq + 1));
params.computeIfAbsent(key, ignored -> new ArrayList<>()).add(value);
}
for (String key : params.keySet()) {
if (!key.equals("limit") && !key.equals("cursor")) {
throw ApiException.invalid("Неподдерживаемый параметр запроса");
}
}
Integer limit = null;
if (params.containsKey("limit")) {
List<String> values = params.get("limit");
if (values.size() != 1 || !values.get(0).matches("[0-9]{1,3}")) {
throw ApiException.invalid("Некорректный limit");
}
int parsed = Integer.parseInt(values.get(0));
if (parsed < 1 || parsed > 100) {
throw ApiException.invalid("Некорректный limit");
}
limit = parsed;
}
String cursor = null;
if (params.containsKey("cursor")) {
List<String> values = params.get("cursor");
if (values.size() != 1 || values.get(0).isEmpty()) {
throw ApiException.invalid("Некорректный cursor");
}
cursor = values.get(0);
}
return new Query(limit, cursor);
}
private static String decode(String value) {
try {
return URLDecoder.decode(value, StandardCharsets.UTF_8);
} catch (IllegalArgumentException exception) {
throw ApiException.invalid("Некорректная строка запроса");
}
}
private <T> int writePage(
HttpExchange exchange,
String requestId,
List<T> sorted,
Query query,
String kind,
UUID scope,
java.util.function.Function<T, Instant> createdAt,
java.util.function.Function<T, UUID> id,
java.util.function.Function<T, ObjectNode> json) throws IOException {
int limit = query.limit == null ? 50 : query.limit;
int start = 0;
if (query.cursor != null) {
Position position = decodeCursor(query.cursor, kind, scope);
while (start < sorted.size()) {
T item = sorted.get(start);
if (after(createdAt.apply(item), id.apply(item), position.createdAt, position.id)) {
break;
}
start++;
}
}
int end = Math.min(start + limit, sorted.size());
ObjectNode page = JSON.createObjectNode();
ArrayNode items = page.putArray("items");
for (int i = start; i < end; i++) {
items.add(json.apply(sorted.get(i)));
}
if (end < sorted.size() && end > start) {
T last = sorted.get(end - 1);
page.put("next_cursor", encodeCursor(kind, scope, createdAt.apply(last), id.apply(last)));
} else {
page.putNull("next_cursor");
}
return writeJson(exchange, requestId, 200, page);
}
private static boolean after(Instant leftTime, UUID leftId, Instant rightTime, UUID rightId) {
int compared = leftTime.compareTo(rightTime);
if (compared != 0) {
return compared > 0;
}
return leftId.compareTo(rightId) > 0;
}
private static String encodeCursor(String kind, UUID scope, Instant createdAt, UUID id) {
String raw = kind + "|" + scope + "|" + DateTimeFormatter.ISO_INSTANT.format(createdAt) + "|" + id;
return Base64.getUrlEncoder().withoutPadding().encodeToString(raw.getBytes(StandardCharsets.UTF_8));
}
private static Position decodeCursor(String cursor, String kind, UUID scope) {
byte[] decoded;
try {
decoded = Base64.getUrlDecoder().decode(pad(cursor));
} catch (IllegalArgumentException exception) {
throw ApiException.invalid("Некорректный cursor");
}
String raw = new String(decoded, StandardCharsets.UTF_8);
String[] parts = raw.split("\\|", -1);
if (parts.length != 4) {
throw ApiException.invalid("Некорректный cursor");
}
if (!parts[0].equals(kind)) {
throw ApiException.invalid("Cursor относится к другому ресурсу");
}
UUID cursorScope;
Instant createdAt;
UUID id;
try {
cursorScope = UUID.fromString(parts[1]);
createdAt = Instant.parse(parts[2]);
id = UUID.fromString(parts[3]);
} catch (IllegalArgumentException exception) {
throw ApiException.invalid("Некорректный cursor");
}
if (!cursorScope.equals(scope)) {
throw ApiException.invalid("Cursor относится к другому ресурсу");
}
return new Position(createdAt, id);
}
private static String pad(String value) {
int mod = value.length() % 4;
if (mod == 0) {
return value;
}
return value + "====".substring(mod);
}
private static ObjectNode health() {
return JSON.createObjectNode().put("status", "ok");
}
private static ObjectNode userJson(User user) {
ObjectNode node = JSON.createObjectNode();
node.put("id", user.id().toString());
node.put("username", user.username());
node.put("display_name", user.displayName());
node.put("created_at", DateTimeFormatter.ISO_INSTANT.format(user.createdAt()));
return node;
}
private static ObjectNode chatJson(Chat chat) {
ObjectNode node = JSON.createObjectNode();
node.put("id", chat.id().toString());
node.put("title", chat.title());
ArrayNode members = node.putArray("member_ids");
for (UUID memberId : chat.memberIds()) {
members.add(memberId.toString());
}
node.put("created_at", DateTimeFormatter.ISO_INSTANT.format(chat.createdAt()));
return node;
}
private ObjectNode messageJson(Message message) {
ObjectNode node = JSON.createObjectNode();
node.put("id", message.id().toString());
node.put("chat_id", message.chatId().toString());
node.put("sender_id", message.senderId().toString());
node.put("text", message.text());
node.put("created_at", DateTimeFormatter.ISO_INSTANT.format(message.createdAt()));
return node;
}
private int writeJson(HttpExchange exchange, String requestId, int status, JsonNode body) throws IOException {
return writeJson(exchange, requestId, status, body, null);
}
private int writeJson(HttpExchange exchange, String requestId, int status, JsonNode body, String challenge) throws IOException {
byte[] bytes = JSON.writeValueAsBytes(body);
return writeBytes(exchange, requestId, status, bytes, challenge);
}
private int writeError(HttpExchange exchange, String requestId, ApiException exception) {
ObjectNode body = JSON.createObjectNode();
ObjectNode errorNode = body.putObject("error");
errorNode.put("code", exception.code);
errorNode.put("message", exception.clientMessage);
errorNode.put("request_id", requestId);
try {
String challenge = exception.status == 401
? (exchange.getRequestURI().getPath().equals("/api/v1/auth/sessions")
? "Basic realm=\"messenger\", charset=\"UTF-8\"" : "Bearer realm=\"messenger\"")
: null;
return writeJson(exchange, requestId, exception.status, body, challenge);
} catch (IOException ioException) {
error.accept("event=write_failed type=" + ioException.getClass().getName());
return exception.status;
}
}
private int writeBytes(HttpExchange exchange, String requestId, int status, byte[] body, String challenge) throws IOException {
exchange.getResponseHeaders().set("Content-Type", "application/json; charset=utf-8");
exchange.getResponseHeaders().set("X-Request-Id", requestId);
exchange.getResponseHeaders().set("X-Instance-Id", instanceId);
if (challenge != null) exchange.getResponseHeaders().set("WWW-Authenticate", challenge);
exchange.sendResponseHeaders(status, body.length);
try (OutputStream output = exchange.getResponseBody()) {
output.write(body);
}
return status;
}
private static String sha256(String value) {
try {
byte[] digest = MessageDigest.getInstance("SHA-256").digest(value.getBytes(StandardCharsets.UTF_8));
return Base64.getUrlEncoder().withoutPadding().encodeToString(digest);
} catch (Exception e) { throw ApiException.internalError(); }
}
private record Query(Integer limit, String cursor) {
}
private record Position(Instant createdAt, UUID id) {
}
private record ChatRoute(String idText, boolean messages) {
}
}