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 info; private final Consumer error; private final int port; private final String instanceId = System.getenv().getOrDefault("INSTANCE_ID", UUID.randomUUID().toString()); private MessengerServer(String host, int port, Consumer info, Consumer 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 info, Consumer 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 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 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 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 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 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 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> 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 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 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 int writePage( HttpExchange exchange, String requestId, List sorted, Query query, String kind, UUID scope, java.util.function.Function createdAt, java.util.function.Function id, java.util.function.Function 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) { } }