diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 8ceefa10..4e655db2 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,18 +1,31 @@ ## Лабораторная 2 -Автор / группа: TODO -Целевая оценка (3/4/5): TODO -Трек 5, если заявлен: TODO +Автор / группа: Гуреев Дмитрий, БПИ2301 +Целевая оценка (3/4/5): **5** +Трек 5, если заявлен: **Трек 1 — согласованность кэша (cache stampede / single-flight)** -Что реализовано и что перенесено: TODO -Команды запуска из чистого clone: TODO -Результаты проверок и ссылка на REPORT.md: TODO -Ограничения / известные ошибки: TODO -Источники и использование ИИ: TODO +### Что реализовано и что перенесено -- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. -- [ ] Контракт и публичные тесты не ослаблены. -- [ ] make check и make test выполнены; приложен реальный вывод. -- [ ] Сценарии отказов/безопасности своего уровня воспроизведены. -- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. -- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. +**Из Lab1:** REST-контракт users/chats/messages, `X-Request-Id`, курсорная пагинация сообщений. + +**Lab2:** +- PostgreSQL + Flyway (users, chats, chat_members, messages, sessions) +- Регистрация с BCrypt; вход Basic → opaque Bearer; expiry; logout; сессии в БД +- Docker Compose: API + Postgres + Redis, named volumes; `scripts/restart.sh` без `down -v` +- Redis — кэш сессий (`session: → userId`, TTL); источник истины — PostgreSQL +- Keyset-пагинация сообщений + индекс `(chat_id, created_at DESC, id DESC)`; EXPLAIN на ≥10k +- Гонка username → 409; createChat в одной транзакции +- **Трек 1:** single-flight в `resolveUserByBearer`; замеры после FLUSHDB; read-after-write; restart Redis + +Подробности, таблицы отказов и эксперимент — в **[REPORT.md](./REPORT.md)**. + +### Команды запуска из чистого clone + +```bash +git clone https://gitea.privcloud.tech/Dmitry/mtusi2026lab2 +cd mtusi2026lab2/Lido +docker compose up -d --build +curl -sf http://localhost:8080/health/live || curl -sf http://localhost:8080/actuator/health +cd .. +make test BASE_URL=http://localhost:8080 +make test-persistence ACTION_SCRIPT=scripts/restart.sh \ No newline at end of file diff --git a/Lido/.dockerignore b/Lido/.dockerignore new file mode 100644 index 00000000..2d7fae82 --- /dev/null +++ b/Lido/.dockerignore @@ -0,0 +1,5 @@ +.gradle +build +.git +*.iml +.idea \ No newline at end of file diff --git a/Lido/.gitignore b/Lido/.gitignore new file mode 100644 index 00000000..b1d77e7b --- /dev/null +++ b/Lido/.gitignore @@ -0,0 +1,2 @@ +build.gradle.kts +.gradle diff --git a/Lido/Dockerfile b/Lido/Dockerfile new file mode 100644 index 00000000..7236f18c --- /dev/null +++ b/Lido/Dockerfile @@ -0,0 +1,23 @@ +FROM eclipse-temurin:22-jdk-alpine AS builder +WORKDIR /app +RUN apk add --no-cache dos2unix +COPY gradlew . +COPY gradle gradle +COPY build.gradle.* settings.gradle* build.gradle.kts* settings.gradle.kts* ./ +RUN dos2unix gradlew && chmod +x gradlew +RUN ./gradlew dependencies --no-daemon || true +COPY src src +RUN ./gradlew bootJar -x test --no-daemon + +FROM eclipse-temurin:22-jre-alpine AS runtime +WORKDIR /app +RUN addgroup -S appgroup && adduser -S appuser -G appgroup +COPY --from=builder /app/build/libs/*.jar app.jar +RUN chown -R appuser:appgroup /app +USER appuser +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --retries=3 \ + CMD wget --no-verbose --tries=1 --spider http://localhost:8080/actuator/health || exit 1 + +ENTRYPOINT ["java", "-jar", "app.jar"] \ No newline at end of file diff --git a/Lido/build.gradle.kts b/Lido/build.gradle.kts new file mode 100644 index 00000000..ccce7729 --- /dev/null +++ b/Lido/build.gradle.kts @@ -0,0 +1,42 @@ +plugins { + java + id("org.springframework.boot") version "3.3.4" + id("io.spring.dependency-management") version "1.1.6" +} + +group = "org.example" +version = "1.0-SNAPSHOT" + +java { + toolchain { + languageVersion.set(JavaLanguageVersion.of(22)) + } +} + +repositories { + mavenCentral() +} + +dependencies { + implementation("org.springframework.boot:spring-boot-starter-web") + implementation("org.springframework.boot:spring-boot-starter-validation") + compileOnly("org.projectlombok:lombok") + annotationProcessor("org.projectlombok:lombok") + testCompileOnly("org.projectlombok:lombok") + testAnnotationProcessor("org.projectlombok:lombok") + testImplementation("org.springframework.boot:spring-boot-starter-test") + testImplementation(platform("org.junit:junit-bom:6.0.0")) + testImplementation("org.junit.jupiter:junit-jupiter") + testRuntimeOnly("org.junit.platform:junit-platform-launcher") + implementation("org.springframework.boot:spring-boot-starter-actuator") + implementation("org.springframework.boot:spring-boot-starter-data-jpa") + runtimeOnly("org.postgresql:postgresql") + implementation("org.flywaydb:flyway-core") + implementation("org.flywaydb:flyway-database-postgresql") + implementation("org.springframework.security:spring-security-crypto") + implementation("org.springframework.boot:spring-boot-starter-data-redis") +} + +tasks.test { + useJUnitPlatform() +} \ No newline at end of file diff --git a/Lido/docker-compose.yml b/Lido/docker-compose.yml new file mode 100644 index 00000000..dec3726e --- /dev/null +++ b/Lido/docker-compose.yml @@ -0,0 +1,57 @@ +services: + db: + image: postgres:16-alpine + container_name: Lido-db + environment: + POSTGRES_DB: lido_db + POSTGRES_USER: user + POSTGRES_PASSWORD: user + ports: + - "5433:5432" + volumes: + - messenger_pg_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U user -d lido_db"] + interval: 5s + timeout: 5s + retries: 5 + + redis: + image: redis:7-alpine + container_name: lido-redis + ports: + - "6379:6379" + volumes: + - lido_redis_data:/data + command: [ "redis-server", "--appendonly", "yes" ] + healthcheck: + test: [ "CMD", "redis-cli", "ping" ] + interval: 5s + timeout: 3s + retries: 10 + + + api: + build: + context: . + dockerfile: Dockerfile + container_name: lido-app + depends_on: + db: + condition: service_healthy + redis: + condition: service_healthy + environment: + SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/lido_db + SPRING_DATASOURCE_USERNAME: user + SPRING_DATASOURCE_PASSWORD: user + SERVER_PORT: "8080" + SPRING_DATA_REDIS_HOST: redis + SPRING_DATA_REDIS_PORT: "6379" + SESSION_TTL_SECONDS: "604800" + ports: + - "8080:8080" + +volumes: + messenger_pg_data: + lido_redis_data: \ No newline at end of file diff --git a/Lido/docs/arch/model.c4 b/Lido/docs/arch/model.c4 new file mode 100644 index 00000000..40093d0a --- /dev/null +++ b/Lido/docs/arch/model.c4 @@ -0,0 +1,11 @@ +model { + messenger = softwareSystem "Messenger" { + api = container "API" "Spring Boot" { + userSvc = component "UserService" + chatSvc = component "ChatService" + msgSvc = component "MessageService" + } + db = container "PostgreSQL" "users, chats, chat_members, messages" + } + api -> db "JDBC / Flyway" +} \ No newline at end of file diff --git a/Lido/gradle/wrapper/gradle-wrapper.jar b/Lido/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 00000000..e6441136 Binary files /dev/null and b/Lido/gradle/wrapper/gradle-wrapper.jar differ diff --git a/Lido/gradle/wrapper/gradle-wrapper.properties b/Lido/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 00000000..45a79d25 --- /dev/null +++ b/Lido/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,8 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip +networkTimeout=10000 +validateDistributionUrl=true +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists + diff --git a/Lido/gradlew b/Lido/gradlew new file mode 100755 index 00000000..b740cf13 --- /dev/null +++ b/Lido/gradlew @@ -0,0 +1,249 @@ +#!/bin/sh + +# +# Copyright © 2015-2021 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + org.gradle.wrapper.GradleWrapperMain \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/Lido/gradlew.bat b/Lido/gradlew.bat new file mode 100644 index 00000000..7101f8e4 --- /dev/null +++ b/Lido/gradlew.bat @@ -0,0 +1,92 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/Lido/settings.gradle.kts b/Lido/settings.gradle.kts new file mode 100644 index 00000000..b27426c4 --- /dev/null +++ b/Lido/settings.gradle.kts @@ -0,0 +1 @@ +rootProject.name = "Lido" diff --git a/Lido/src/main/java/org/example/LidoApplication.java b/Lido/src/main/java/org/example/LidoApplication.java new file mode 100644 index 00000000..96bf147d --- /dev/null +++ b/Lido/src/main/java/org/example/LidoApplication.java @@ -0,0 +1,11 @@ +package org.example; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; + +@SpringBootApplication +public class LidoApplication { + public static void main(String[] args) { + SpringApplication.run(LidoApplication.class, args); + } +} diff --git a/Lido/src/main/java/org/example/config/AuthFilter.java b/Lido/src/main/java/org/example/config/AuthFilter.java new file mode 100644 index 00000000..534eb231 --- /dev/null +++ b/Lido/src/main/java/org/example/config/AuthFilter.java @@ -0,0 +1,44 @@ +package org.example.config; + +import jakarta.servlet.FilterChain; +import jakarta.servlet.ServletException; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.example.repository.SessionRepository; +import org.example.service.AuthService; +import org.springframework.stereotype.Component; +import org.springframework.web.filter.OncePerRequestFilter; + +import java.io.IOException; + +@Slf4j +@Component +@RequiredArgsConstructor +public class AuthFilter extends OncePerRequestFilter { + + private final AuthService authService; + private final SessionRepository sessionRepository; + + @Override + protected void doFilterInternal(HttpServletRequest request, + HttpServletResponse response, + FilterChain filterChain) + throws ServletException, IOException { + + String auth = request.getHeader("Authorization"); + if (auth != null && auth.startsWith("Bearer ")) { + String token = auth.substring(7).trim(); + if (!token.isEmpty()) { + authService.resolveUserByBearer(token) + .ifPresent(UserContext::setCurrentUser); + } + } + try { + filterChain.doFilter(request, response); + } finally { + UserContext.clear(); + } + } +} \ No newline at end of file diff --git a/Lido/src/main/java/org/example/config/PasswordConfig.java b/Lido/src/main/java/org/example/config/PasswordConfig.java new file mode 100644 index 00000000..814a1b47 --- /dev/null +++ b/Lido/src/main/java/org/example/config/PasswordConfig.java @@ -0,0 +1,15 @@ +package org.example.config; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; +import org.springframework.security.crypto.password.PasswordEncoder; + +@Configuration +public class PasswordConfig { + + @Bean + public PasswordEncoder passwordEncoder() { + return new BCryptPasswordEncoder(); + } +} diff --git a/Lido/src/main/java/org/example/config/RequestIdFilter.java b/Lido/src/main/java/org/example/config/RequestIdFilter.java new file mode 100644 index 00000000..5277ccba --- /dev/null +++ b/Lido/src/main/java/org/example/config/RequestIdFilter.java @@ -0,0 +1,43 @@ +package org.example.config; + + +import jakarta.servlet.FilterChain; +import jakarta.servlet.ServletException; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import org.slf4j.MDC; +import org.springframework.stereotype.Component; +import org.springframework.web.filter.OncePerRequestFilter; + +import java.io.IOException; +import java.util.UUID; + +@Component +public class RequestIdFilter extends OncePerRequestFilter { + + public static final String REQUEST_ID_HEADER = "X-Request-Id"; + + + @Override + protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) + throws ServletException, IOException { + + String requestId = request.getHeader(REQUEST_ID_HEADER); + + if (requestId == null || requestId.trim().isEmpty()) { + requestId = UUID.randomUUID().toString(); + } + + MDC.put(REQUEST_ID_HEADER, requestId); + + request.setAttribute(REQUEST_ID_HEADER, requestId); + response.setHeader(REQUEST_ID_HEADER, requestId); + + try { + filterChain.doFilter(request, response); + } finally { + MDC.remove(REQUEST_ID_HEADER); + } + + } +} diff --git a/Lido/src/main/java/org/example/config/TokenHasher.java b/Lido/src/main/java/org/example/config/TokenHasher.java new file mode 100644 index 00000000..6f6c9d44 --- /dev/null +++ b/Lido/src/main/java/org/example/config/TokenHasher.java @@ -0,0 +1,28 @@ +package org.example.config; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.security.SecureRandom; +import java.util.HexFormat; + +public final class TokenHasher { + private static final SecureRandom RANDOM = new SecureRandom(); + + public TokenHasher() {} + + public static String newRawToken(){ + byte[] bytes = new byte[32]; + RANDOM.nextBytes(bytes); + return HexFormat.of().formatHex(bytes); + } + + public static String sha256(String rawToken) { + try { + MessageDigest md = MessageDigest.getInstance("SHA-256"); + byte[] dig = md.digest(rawToken.getBytes(StandardCharsets.UTF_8)); + return HexFormat.of().formatHex(dig); + } catch (Exception e) { + throw new IllegalStateException(e); + } + } +} diff --git a/Lido/src/main/java/org/example/config/UserContext.java b/Lido/src/main/java/org/example/config/UserContext.java new file mode 100644 index 00000000..6017a387 --- /dev/null +++ b/Lido/src/main/java/org/example/config/UserContext.java @@ -0,0 +1,19 @@ +package org.example.config; + +import org.example.model.User; + +public class UserContext { + private static final ThreadLocal CURRENT_USER = new ThreadLocal<>(); + + public static void setCurrentUser(User user) { + CURRENT_USER.set(user); + } + + public static User getCurrentUser() { + return CURRENT_USER.get(); + } + + public static void clear() { + CURRENT_USER.remove(); + } +} diff --git a/Lido/src/main/java/org/example/controller/AuthController.java b/Lido/src/main/java/org/example/controller/AuthController.java new file mode 100644 index 00000000..2457a378 --- /dev/null +++ b/Lido/src/main/java/org/example/controller/AuthController.java @@ -0,0 +1,66 @@ +package org.example.controller; + + +import jakarta.servlet.http.HttpServletRequest; +import lombok.RequiredArgsConstructor; +import org.example.dto.response.SessionInfoResponse; +import org.example.dto.response.SessionResponse; +import org.example.exception.UnauthorizedException; +import org.example.service.AuthService; +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.annotation.*; + +import java.nio.charset.StandardCharsets; +import java.util.Base64; +import java.util.List; + +@RestController +@RequestMapping("/api/v1/auth") +@RequiredArgsConstructor +public class AuthController { + + private final AuthService authService; + + @PostMapping("/sessions") + @ResponseStatus(HttpStatus.CREATED) + public SessionResponse login(HttpServletRequest request) { + String header = request.getHeader("Authorization"); + if (header == null || !header.startsWith("Basic ")) { + throw new UnauthorizedException("Unauthorized"); + } + String decoded; + try { + decoded = new String( + Base64.getDecoder().decode(header.substring(6).trim()), + StandardCharsets.UTF_8); + } catch (IllegalArgumentException e) { + throw new UnauthorizedException("Unauthorized"); + } + int colon = decoded.indexOf(':'); + if (colon < 0) { + throw new UnauthorizedException("Unauthorized"); + } + String username = decoded.substring(0, colon); + String password = decoded.substring(colon + 1); + return authService.login(username, password); + } + + @DeleteMapping("/sessions/current") + @ResponseStatus(HttpStatus.NO_CONTENT) + public void revokeCurrent(HttpServletRequest request) { + String header = request.getHeader("Authorization"); + if (header == null || !header.startsWith("Bearer ")) { + throw new UnauthorizedException("Unauthorized"); + } + String token = header.substring(7).trim(); + if (token.isEmpty()) { + throw new UnauthorizedException("Unauthorized"); + } + authService.logoutCurrent(token); + } + + @GetMapping("/sessions") + public List sessions() { + return authService.listSessionsForCurrentUser(); + } +} diff --git a/Lido/src/main/java/org/example/controller/ChatController.java b/Lido/src/main/java/org/example/controller/ChatController.java new file mode 100644 index 00000000..cdd70811 --- /dev/null +++ b/Lido/src/main/java/org/example/controller/ChatController.java @@ -0,0 +1,110 @@ +package org.example.controller; + +import jakarta.validation.Valid; +import jakarta.validation.constraints.Min; +import lombok.RequiredArgsConstructor; +import org.example.dto.ChatPage; +import org.example.dto.MessagePage; +import org.example.dto.create.CreateChatDto; +import org.example.dto.create.CreateMessageDto; +import org.example.dto.response.ChatResponse; +import org.example.dto.update.UpdateChatDto; +import org.example.dto.update.UpdateMessageDto; +import org.example.model.Message; +import org.example.service.ChatService; +import org.example.service.MessageService; +import org.example.service.UserService; +import org.springframework.http.HttpStatus; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +import java.util.UUID; + +@RestController +@RequestMapping("/api/v1/chats") +@RequiredArgsConstructor +@Validated +public class ChatController { + + private final ChatService chatService; + private final MessageService messageService; + private final UserService userService; + + // ——— Chats ——— + + @PostMapping + @ResponseStatus(HttpStatus.CREATED) + public ChatResponse createChat(@Valid @RequestBody CreateChatDto dto) { + return chatService.createChat(dto); + } + + @GetMapping + public ChatPage getChats( + @RequestParam(defaultValue = "50") + @Min(value = 1, message = "limit must be >= 1") int limit + ) { + return chatService.getChatsForCurrentUser(limit); + } + + @GetMapping("/{id}") + public ChatResponse getChatById(@PathVariable UUID id) { + return chatService.getChatById(id); + } + + @PutMapping("/{id}") + public ChatResponse updateChat( + @PathVariable UUID id, + @Valid @RequestBody UpdateChatDto object + ) { + return chatService.updateChat(id, object); + } + + @DeleteMapping("/{id}") + @ResponseStatus(HttpStatus.NO_CONTENT) + public void deleteChat(@PathVariable UUID id) { + chatService.deleteChat(id); + } + + // ——— Messages ——— + + @PostMapping("/{id}/messages") + @ResponseStatus(HttpStatus.CREATED) + public Message sendMessage( + @PathVariable("id") UUID id, + @Valid @RequestBody CreateMessageDto messageDto + ) { + UUID senderId = userService.getCurrentUser().getId(); + return messageService.sendMessage(id, senderId, messageDto); + } + + @GetMapping("/{id}/messages") + public MessagePage getMessages( + @PathVariable("id") UUID id, + @RequestParam(required = false) String cursor, + @RequestParam(defaultValue = "50") + @Min(value = 1, message = "limit must be >= 1") int limit + ) { + UUID userId = userService.getCurrentUser().getId(); + return messageService.getMessage(id, userId, cursor, limit); + } + + @PutMapping("/{id}/messages/{messageId}") + public Message updateMessage( + @PathVariable("id") UUID id, + @PathVariable UUID messageId, + @Valid @RequestBody UpdateMessageDto object + ) { + UUID userId = userService.getCurrentUser().getId(); + return messageService.updateMessage(id, messageId, userId, object); + } + + @DeleteMapping("/{id}/messages/{messageId}") + @ResponseStatus(HttpStatus.NO_CONTENT) + public void deleteMessage( + @PathVariable("id") UUID id, + @PathVariable UUID messageId + ) { + UUID userId = userService.getCurrentUser().getId(); + messageService.deleteMessage(id, messageId, userId); + } +} \ No newline at end of file diff --git a/Lido/src/main/java/org/example/controller/HealthController.java b/Lido/src/main/java/org/example/controller/HealthController.java new file mode 100644 index 00000000..8d4ccffc --- /dev/null +++ b/Lido/src/main/java/org/example/controller/HealthController.java @@ -0,0 +1,19 @@ +package org.example.controller; + +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.Map; + +@RestController +@RequestMapping("/health") +public class HealthController { + + @GetMapping({"", "/live", "/ready"}) + public ResponseEntity> health() { + return ResponseEntity.ok(Map.of("status", "ok")); + } +} + diff --git a/Lido/src/main/java/org/example/controller/UserController.java b/Lido/src/main/java/org/example/controller/UserController.java new file mode 100644 index 00000000..e914f91b --- /dev/null +++ b/Lido/src/main/java/org/example/controller/UserController.java @@ -0,0 +1,48 @@ +package org.example.controller; + +import jakarta.validation.Valid; +import lombok.RequiredArgsConstructor; +import org.example.dto.create.CreateUserDto; +import org.example.dto.update.UpdateUserDto; +import org.example.model.User; +import org.example.service.UserService; +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.annotation.*; + +import java.util.UUID; + +@RestController +@RequestMapping("/api/v1/users") +@RequiredArgsConstructor +public class UserController { + + private final UserService userService; + + @PostMapping + @ResponseStatus(HttpStatus.CREATED) + public User createUser(@Valid @RequestBody CreateUserDto dto) { + return userService.createUser(dto); + } + + @GetMapping("/me") + public User getCurrentUser() { + return userService.getCurrentUser(); + } + + @GetMapping("/{id}") + public User getUserById(@PathVariable UUID id) { + return userService.getUserById(id); + } + + @PutMapping("/{id}") + public User updateUser(@PathVariable String id, + @Valid @RequestBody UpdateUserDto object) { + return userService.updateUser(id, object); + } + + @DeleteMapping("/{id}") + @ResponseStatus(HttpStatus.NO_CONTENT) + public void delete(@PathVariable String id) { + userService.deleteUser(id); + } +} \ No newline at end of file diff --git a/Lido/src/main/java/org/example/dto/ChatPage.java b/Lido/src/main/java/org/example/dto/ChatPage.java new file mode 100644 index 00000000..275ef1b3 --- /dev/null +++ b/Lido/src/main/java/org/example/dto/ChatPage.java @@ -0,0 +1,22 @@ +package org.example.dto; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.PropertyNamingStrategies; +import com.fasterxml.jackson.databind.annotation.JsonNaming; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.example.dto.response.ChatResponse; +import org.example.model.Chat; + +import java.util.List; + +@Data +@AllArgsConstructor +@NoArgsConstructor +@JsonNaming(PropertyNamingStrategies.SnakeCaseStrategy.class) +public class ChatPage { + private List items; + @JsonProperty("next_cursor") + private String nextCursor; +} diff --git a/Lido/src/main/java/org/example/dto/ErrorDetail.java b/Lido/src/main/java/org/example/dto/ErrorDetail.java new file mode 100644 index 00000000..22bb3ea5 --- /dev/null +++ b/Lido/src/main/java/org/example/dto/ErrorDetail.java @@ -0,0 +1,14 @@ +package org.example.dto; + + +import lombok.AllArgsConstructor; +import lombok.Data; + +@Data +@AllArgsConstructor +public class ErrorDetail { + private String code; + private String message; + private String request_id; +} + diff --git a/Lido/src/main/java/org/example/dto/MessagePage.java b/Lido/src/main/java/org/example/dto/MessagePage.java new file mode 100644 index 00000000..058afb76 --- /dev/null +++ b/Lido/src/main/java/org/example/dto/MessagePage.java @@ -0,0 +1,18 @@ +package org.example.dto; + + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.RequiredArgsConstructor; +import org.example.model.Message; + +import java.util.List; + +@Data +@AllArgsConstructor +@RequiredArgsConstructor +public class MessagePage { + private List items; + private String nextCursor; +} + diff --git a/Lido/src/main/java/org/example/dto/create/CreateChatDto.java b/Lido/src/main/java/org/example/dto/create/CreateChatDto.java new file mode 100644 index 00000000..c2dd9114 --- /dev/null +++ b/Lido/src/main/java/org/example/dto/create/CreateChatDto.java @@ -0,0 +1,21 @@ +package org.example.dto.create; + +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 lombok.Data; +import java.util.List; +import java.util.UUID; + +@Data +public class CreateChatDto { + @NotBlank(message = "Title не может быть пустым") + @Size(max = 100, message = "Title не должен превышать 32 символов") + private String title; + + @JsonProperty("member_ids") + @NotEmpty(message = "Список участников не может быть пустым") + private List<@NotNull UUID> memberIds; +} diff --git a/Lido/src/main/java/org/example/dto/create/CreateMessageDto.java b/Lido/src/main/java/org/example/dto/create/CreateMessageDto.java new file mode 100644 index 00000000..fd53b6d0 --- /dev/null +++ b/Lido/src/main/java/org/example/dto/create/CreateMessageDto.java @@ -0,0 +1,12 @@ +package org.example.dto.create; + +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.Size; +import lombok.Data; + +@Data +public class CreateMessageDto { + @NotBlank(message = "Текст сообщения не может быть пустым") + @Size(max = 4000, message = "Максимальная длина сообщения — 1024 символов") + private String text; +} diff --git a/Lido/src/main/java/org/example/dto/create/CreateUserDto.java b/Lido/src/main/java/org/example/dto/create/CreateUserDto.java new file mode 100644 index 00000000..1a5e5ae5 --- /dev/null +++ b/Lido/src/main/java/org/example/dto/create/CreateUserDto.java @@ -0,0 +1,26 @@ +package org.example.dto.create; + +import com.fasterxml.jackson.annotation.JsonProperty; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.Pattern; +import jakarta.validation.constraints.Size; +import lombok.Data; + +@Data +public class CreateUserDto { + @NotBlank(message = "Username не может быть пустым") + @Size(max = 64, message = "Username не должен превышать 64 символов") + @JsonProperty("username") + @Pattern(regexp = "^[a-z0-9_]{3,32}$") + private String username; + + @NotBlank(message = "Display name не может быть пустым") + @Size(max = 100, message = "Display name не должен быть больше 128 символов") + @JsonProperty("display_name") + private String displayName; + + @NotBlank(message = "Password не может быть пустым") + @Size(min = 12, max = 128, message = "Password: 12–128 символа") + private String password; +} + diff --git a/Lido/src/main/java/org/example/dto/response/ChatResponse.java b/Lido/src/main/java/org/example/dto/response/ChatResponse.java new file mode 100644 index 00000000..5356fb3b --- /dev/null +++ b/Lido/src/main/java/org/example/dto/response/ChatResponse.java @@ -0,0 +1,24 @@ +package org.example.dto.response; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.time.Instant; +import java.util.List; +import java.util.UUID; + +@Data +@Builder +@AllArgsConstructor +@NoArgsConstructor +public class ChatResponse { + private UUID id; + private String title; + @JsonProperty("member_ids") + private List memberIds; + @JsonProperty("created_at") + private Instant createdAt; +} diff --git a/Lido/src/main/java/org/example/dto/response/ErrorResponse.java b/Lido/src/main/java/org/example/dto/response/ErrorResponse.java new file mode 100644 index 00000000..60b6590f --- /dev/null +++ b/Lido/src/main/java/org/example/dto/response/ErrorResponse.java @@ -0,0 +1,11 @@ +package org.example.dto.response; + +import lombok.AllArgsConstructor; +import lombok.Data; +import org.example.dto.ErrorDetail; + +@Data +@AllArgsConstructor +public class ErrorResponse { + private ErrorDetail error; +} diff --git a/Lido/src/main/java/org/example/dto/response/MessageResponse.java b/Lido/src/main/java/org/example/dto/response/MessageResponse.java new file mode 100644 index 00000000..204f6e3e --- /dev/null +++ b/Lido/src/main/java/org/example/dto/response/MessageResponse.java @@ -0,0 +1,25 @@ +package org.example.dto.response; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.time.Instant; +import java.util.UUID; + +@Data +@Builder +@AllArgsConstructor +@NoArgsConstructor +public class MessageResponse { + private UUID id; + @JsonProperty("chat_id") + private UUID chatId; + @JsonProperty("sender_id") + private UUID senderId; + private String text; + @JsonProperty("created_at") + private Instant createdAt; +} diff --git a/Lido/src/main/java/org/example/dto/response/SessionInfoResponse.java b/Lido/src/main/java/org/example/dto/response/SessionInfoResponse.java new file mode 100644 index 00000000..f1cc454e --- /dev/null +++ b/Lido/src/main/java/org/example/dto/response/SessionInfoResponse.java @@ -0,0 +1,25 @@ +package org.example.dto.response; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.time.Instant; +import java.util.UUID; + +@Data +@Builder +@AllArgsConstructor +@NoArgsConstructor +public class SessionInfoResponse { + private UUID id; + @JsonProperty("created_at") + private Instant createdAt; + @JsonProperty("expires_at") + private Instant expiresAt; + @JsonProperty("revoked_at") + private Instant revokedAt; + private boolean active; +} \ No newline at end of file diff --git a/Lido/src/main/java/org/example/dto/response/SessionResponse.java b/Lido/src/main/java/org/example/dto/response/SessionResponse.java new file mode 100644 index 00000000..85b21bc1 --- /dev/null +++ b/Lido/src/main/java/org/example/dto/response/SessionResponse.java @@ -0,0 +1,24 @@ +package org.example.dto.response; + + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.*; + +import java.time.Instant; + +@Builder +@AllArgsConstructor +@NoArgsConstructor +@Data +public class SessionResponse { + + private String token; + + @JsonProperty("token_type") + private String tokenType; + + @JsonProperty("expires_at") + private Instant expiresAt; + + private UserResponse user; +} diff --git a/Lido/src/main/java/org/example/dto/response/UserResponse.java b/Lido/src/main/java/org/example/dto/response/UserResponse.java new file mode 100644 index 00000000..ffd6048d --- /dev/null +++ b/Lido/src/main/java/org/example/dto/response/UserResponse.java @@ -0,0 +1,24 @@ +package org.example.dto.response; + + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.time.Instant; +import java.util.UUID; + +@Data +@AllArgsConstructor +@NoArgsConstructor +@Builder +public class UserResponse { + private UUID id; + private String username; + @JsonProperty("display_name") + private String displayName; + @JsonProperty("created_at") + private Instant createdAt; +} diff --git a/Lido/src/main/java/org/example/dto/update/UpdateChatDto.java b/Lido/src/main/java/org/example/dto/update/UpdateChatDto.java new file mode 100644 index 00000000..07b5eeee --- /dev/null +++ b/Lido/src/main/java/org/example/dto/update/UpdateChatDto.java @@ -0,0 +1,12 @@ +package org.example.dto.update; + +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.Size; +import lombok.Data; + +@Data +public class UpdateChatDto { + @NotBlank + @Size(max = 32) + private String title; +} diff --git a/Lido/src/main/java/org/example/dto/update/UpdateMessageDto.java b/Lido/src/main/java/org/example/dto/update/UpdateMessageDto.java new file mode 100644 index 00000000..ab0b789f --- /dev/null +++ b/Lido/src/main/java/org/example/dto/update/UpdateMessageDto.java @@ -0,0 +1,12 @@ +package org.example.dto.update; + +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.Size; +import lombok.Data; + +@Data +public class UpdateMessageDto { + @NotBlank + @Size(max = 1024) + private String text; +} diff --git a/Lido/src/main/java/org/example/dto/update/UpdateUserDto.java b/Lido/src/main/java/org/example/dto/update/UpdateUserDto.java new file mode 100644 index 00000000..b962609e --- /dev/null +++ b/Lido/src/main/java/org/example/dto/update/UpdateUserDto.java @@ -0,0 +1,14 @@ +package org.example.dto.update; + +import com.fasterxml.jackson.annotation.JsonProperty; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.Size; +import lombok.Data; + +@Data +public class UpdateUserDto { + @NotBlank + @Size(max = 128) + @JsonProperty("display_name") + private String displayName; +} diff --git a/Lido/src/main/java/org/example/exception/ForbiddenException.java b/Lido/src/main/java/org/example/exception/ForbiddenException.java new file mode 100644 index 00000000..9c11920e --- /dev/null +++ b/Lido/src/main/java/org/example/exception/ForbiddenException.java @@ -0,0 +1,8 @@ +package org.example.exception; + +public class ForbiddenException extends RuntimeException { + public ForbiddenException(String message) { + super(message); + } +} + diff --git a/Lido/src/main/java/org/example/exception/GlobalExceptionHandler.java b/Lido/src/main/java/org/example/exception/GlobalExceptionHandler.java new file mode 100644 index 00000000..95762036 --- /dev/null +++ b/Lido/src/main/java/org/example/exception/GlobalExceptionHandler.java @@ -0,0 +1,187 @@ +package org.example.exception; + +import jakarta.servlet.http.HttpServletRequest; +import jakarta.validation.ConstraintViolationException; +import lombok.extern.slf4j.Slf4j; +import org.example.config.RequestIdFilter; +import org.example.dto.ErrorDetail; +import org.example.dto.response.ErrorResponse; +import org.springframework.dao.DataIntegrityViolationException; +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.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.RestControllerAdvice; + +import java.util.Map; +import java.util.UUID; + +@Slf4j +@RestControllerAdvice +public class GlobalExceptionHandler { + + private String resolveRequestId(HttpServletRequest request) { + Object attr = request.getAttribute(RequestIdFilter.REQUEST_ID_HEADER); + if (attr instanceof String s && !s.isBlank()) { + return s; + } + String header = request.getHeader(RequestIdFilter.REQUEST_ID_HEADER); + if (header != null && !header.isBlank()) { + return header.trim(); + } + return UUID.randomUUID().toString(); + } + + @ExceptionHandler(NotFoundException.class) + public ResponseEntity handleNotFound(NotFoundException ex, HttpServletRequest request) { + String reqId = resolveRequestId(request); + ErrorResponse body = new ErrorResponse( + new ErrorDetail("not_found", ex.getMessage(), reqId) + ); + return ResponseEntity.status(HttpStatus.NOT_FOUND) + .header("X-Request-Id", reqId) + .body(body); + } + + @ExceptionHandler(ForbiddenException.class) + public ResponseEntity handleForbidden(ForbiddenException ex, HttpServletRequest request) { + String reqId = resolveRequestId(request); + ErrorResponse body = new ErrorResponse( + new ErrorDetail("forbidden", ex.getMessage(), reqId) + ); + // если в openapi нет code "forbidden" — замени на "unauthorized" или как в контракте + return ResponseEntity.status(HttpStatus.FORBIDDEN) + .header("X-Request-Id", reqId) + .body(body); + } + + @ExceptionHandler(MethodArgumentNotValidException.class) + public ResponseEntity handleValidationException( + MethodArgumentNotValidException ex, + HttpServletRequest request + ) { + log.debug("Validation failed", ex); + String reqId = resolveRequestId(request); + ErrorResponse body = new ErrorResponse( + new ErrorDetail("invalid_request", "Validation Failed", reqId) + ); + return ResponseEntity.status(HttpStatus.BAD_REQUEST) + .header("X-Request-Id", reqId) + .body(body); + } + + @ExceptionHandler(HttpMessageNotReadableException.class) + public ResponseEntity handleMalformedJson( + HttpMessageNotReadableException ex, + HttpServletRequest request + ) { + String reqId = resolveRequestId(request); + ErrorResponse body = new ErrorResponse( + new ErrorDetail("invalid_request", "Malformed JSON request body", reqId) + ); + return ResponseEntity.status(HttpStatus.BAD_REQUEST) + .header("X-Request-Id", reqId) + .body(body); + } + + @ExceptionHandler(IllegalArgumentException.class) + public ResponseEntity handleBadRequest( + IllegalArgumentException ex, + HttpServletRequest request + ) { + String reqId = resolveRequestId(request); + ErrorResponse body = new ErrorResponse( + new ErrorDetail("invalid_request", ex.getMessage(), reqId) + ); + return ResponseEntity.status(HttpStatus.BAD_REQUEST) + .header("X-Request-Id", reqId) + .body(body); + } + + @ExceptionHandler(UserAlreadyExistsException.class) + public ResponseEntity handleUserAlreadyExists( + UserAlreadyExistsException ex, + HttpServletRequest request + ) { + String reqId = resolveRequestId(request); + ErrorResponse body = new ErrorResponse( + new ErrorDetail("conflict", ex.getMessage(), reqId) + ); + return ResponseEntity.status(HttpStatus.CONFLICT) + .header("X-Request-Id", reqId) + .body(body); + } + + @ExceptionHandler(UnauthorizedException.class) + public ResponseEntity> handleUnauthorized( + UnauthorizedException ex, + HttpServletRequest request + ) { + String requestId = resolveRequestId(request); + + String path = request.getRequestURI(); + String www; + if (path != null + && path.startsWith("/api/v1/auth/sessions") + && "POST".equalsIgnoreCase(request.getMethod())) { + www = "Basic realm=\"messenger\", charset=\"UTF-8\""; + } else { + www = "Bearer realm=\"messenger\""; + } + + Map body = Map.of( + "error", Map.of( + "code", "unauthorized", + "message", ex.getMessage() != null ? ex.getMessage() : "Unauthorized", + "request_id", requestId + ) + ); + + return ResponseEntity + .status(HttpStatus.UNAUTHORIZED) + .header("X-Request-Id", requestId) + .header("WWW-Authenticate", www) + .body(body); + } + + @ExceptionHandler(Exception.class) + public ResponseEntity handleAllOtherExceptions(Exception ex, HttpServletRequest request) { + log.error("CRITICAL ERROR ON REQUEST: {}", request.getRequestURI(), ex); + String reqId = resolveRequestId(request); + ErrorResponse body = new ErrorResponse( + new ErrorDetail("internal_error", "Internal server error", reqId) + ); + return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) + .header("X-Request-Id", reqId) + .body(body); + } + + @ExceptionHandler(ConstraintViolationException.class) + public ResponseEntity handleConstraintViolation( + ConstraintViolationException ex, + HttpServletRequest request + ) { + String reqId = resolveRequestId(request); + ErrorResponse body = new ErrorResponse( + new ErrorDetail("invalid_request", "Validation Failed", reqId) + ); + return ResponseEntity.status(HttpStatus.BAD_REQUEST) + .header("X-Request-Id", reqId) + .body(body); + } + + @ExceptionHandler(DataIntegrityViolationException.class) + public ResponseEntity handleDataIntegrity( + DataIntegrityViolationException ex, + HttpServletRequest request + ) { + String reqId = resolveRequestId(request); + ErrorResponse body = new ErrorResponse( + new ErrorDetail("conflict", "Conflict", reqId) + ); + return ResponseEntity.status(HttpStatus.CONFLICT) + .header("X-Request-Id", reqId) + .body(body); + } +} \ No newline at end of file diff --git a/Lido/src/main/java/org/example/exception/NotFoundException.java b/Lido/src/main/java/org/example/exception/NotFoundException.java new file mode 100644 index 00000000..1987b90b --- /dev/null +++ b/Lido/src/main/java/org/example/exception/NotFoundException.java @@ -0,0 +1,8 @@ +package org.example.exception; + +public class NotFoundException extends RuntimeException { + public NotFoundException(String message) { + super(message); + } +} + diff --git a/Lido/src/main/java/org/example/exception/UnauthorizedException.java b/Lido/src/main/java/org/example/exception/UnauthorizedException.java new file mode 100644 index 00000000..e019c674 --- /dev/null +++ b/Lido/src/main/java/org/example/exception/UnauthorizedException.java @@ -0,0 +1,19 @@ +package org.example.exception; + +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.annotation.ResponseStatus; + +@ResponseStatus(HttpStatus.UNAUTHORIZED) +public class UnauthorizedException extends RuntimeException { + private final String wwwAuthenticate; + + public UnauthorizedException(String wwwAuthenticate) { + super("Unauthorized"); + this.wwwAuthenticate = wwwAuthenticate; + } + + public String getWwwAuthenticate() { + return wwwAuthenticate; + } +} + diff --git a/Lido/src/main/java/org/example/exception/UserAlreadyExistsException.java b/Lido/src/main/java/org/example/exception/UserAlreadyExistsException.java new file mode 100644 index 00000000..66d4fe8a --- /dev/null +++ b/Lido/src/main/java/org/example/exception/UserAlreadyExistsException.java @@ -0,0 +1,12 @@ +package org.example.exception; + +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.annotation.ResponseStatus; + +@ResponseStatus(HttpStatus.CONFLICT) +public class UserAlreadyExistsException extends RuntimeException { + public UserAlreadyExistsException(String message) { + super(message); + } +} + diff --git a/Lido/src/main/java/org/example/model/Chat.java b/Lido/src/main/java/org/example/model/Chat.java new file mode 100644 index 00000000..4f3c2d56 --- /dev/null +++ b/Lido/src/main/java/org/example/model/Chat.java @@ -0,0 +1,53 @@ +package org.example.model; + + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import jakarta.persistence.*; +import lombok.*; +import org.hibernate.annotations.CreationTimestamp; + +import java.time.Instant; +import java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + + +@Entity +@Table(name = "chats") +@Setter +@Getter +@AllArgsConstructor +@NoArgsConstructor +@Builder +@JsonIgnoreProperties({"hibernateLazyInitializer", "handler"}) +public class Chat { + + @Id + @GeneratedValue(strategy = GenerationType.UUID) + private UUID id; + + @Column(nullable = false, length = 32) + private String title; + + @OneToMany(mappedBy = "chat", fetch = FetchType.LAZY) + @JsonIgnore + @Builder.Default + private List members =new ArrayList<>(); + + @CreationTimestamp + @Column(name = "created_at", nullable = false, updatable = false) + @JsonProperty("created_at") + private Instant createdAt; + + @Transient + @JsonProperty("member_ids") + private List memberIds; + public void setMemberIdsForResponse(List ids) { + this.memberIds = ids; + } + + +} diff --git a/Lido/src/main/java/org/example/model/ChatMember.java b/Lido/src/main/java/org/example/model/ChatMember.java new file mode 100644 index 00000000..2f8a440d --- /dev/null +++ b/Lido/src/main/java/org/example/model/ChatMember.java @@ -0,0 +1,51 @@ +package org.example.model; + + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import jakarta.persistence.*; +import lombok.*; +import org.hibernate.annotations.CreationTimestamp; + +import java.io.Serializable; +import java.time.Instant; +import java.util.UUID; + +@Entity +@Table(name = "chat_members") +@Getter +@Setter +@NoArgsConstructor +@AllArgsConstructor +@Builder +@IdClass(ChatMember.ChatMemberId.class) +@JsonIgnoreProperties({"hibernateLazyInitializer", "handler"}) +public class ChatMember { + + @Id + @Column(name = "chat_id") + private UUID chatId; + + @Id + @Column(name = "user_id", nullable = false) + private UUID userId; + + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @JoinColumn(name = "chat_id", insertable = false, updatable = false) + private Chat chat; + + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @JoinColumn(name = "user_id", insertable = false, updatable = false) + private User user; + + @CreationTimestamp + @Column(name = "joined_at", nullable = false, updatable = false) + private Instant joinedAt; + + @Data + @NoArgsConstructor + @AllArgsConstructor + public static class ChatMemberId implements Serializable { + private UUID chatId; + private UUID userId; + } +} diff --git a/Lido/src/main/java/org/example/model/Message.java b/Lido/src/main/java/org/example/model/Message.java new file mode 100644 index 00000000..fe5bda50 --- /dev/null +++ b/Lido/src/main/java/org/example/model/Message.java @@ -0,0 +1,43 @@ +package org.example.model; + + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import jakarta.persistence.*; +import lombok.*; +import org.hibernate.annotations.CreationTimestamp; + +import java.time.Instant; +import java.time.LocalDateTime; +import java.util.UUID; + +@Entity +@Table(name = "messages") +@Getter +@Setter +@NoArgsConstructor +@AllArgsConstructor +@Builder +@JsonIgnoreProperties({"hibernateLazyInitializer", "handler"}) +public class Message { + @Id + @GeneratedValue(strategy = GenerationType.UUID) + private UUID id; + + @Column(name = "chat_id", nullable = false) + @JsonProperty("chat_id") + private UUID chatId; + + @Column(name = "sender_id", nullable = false) + @JsonProperty("sender_id") + private UUID senderId; + + @Column(nullable = false, columnDefinition = "TEXT") + private String text; + + @CreationTimestamp + @Column(name = "created_at", nullable = false, updatable = false) + @JsonProperty("created_at") + private Instant createdAt; + +} diff --git a/Lido/src/main/java/org/example/model/Session.java b/Lido/src/main/java/org/example/model/Session.java new file mode 100644 index 00000000..c6974d7f --- /dev/null +++ b/Lido/src/main/java/org/example/model/Session.java @@ -0,0 +1,53 @@ +package org.example.model; + + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import jakarta.persistence.*; +import lombok.*; + +import java.time.Instant; +import java.util.UUID; + +@Entity +@Table(name = "sessions") +@Getter +@Setter +@JsonIgnoreProperties({"hibernateLazyInitializer", "handler"}) +@NoArgsConstructor +@AllArgsConstructor +@Builder +public class Session { + + @Id + private UUID id; + + @Column(name = "user_id", nullable = false) + private UUID userId; + + @Column(name = "token", nullable = false, unique = true, length = 64) + private String token; + + @Column(name = "expires_at", nullable = false) + private Instant expiresAt; + + @Column(name = "created_at", nullable = false) + private Instant createdAt; + + @Column(name = "revoked_at") + private Instant revokedAt; + + @PrePersist + void prePersist() { + if (id == null) { + id = UUID.randomUUID(); + } + if (createdAt == null) { + createdAt = Instant.now(); + } + } + + public boolean isActive(Instant now) { + return revokedAt == null && expiresAt.isAfter(now); + } + +} diff --git a/Lido/src/main/java/org/example/model/User.java b/Lido/src/main/java/org/example/model/User.java new file mode 100644 index 00000000..1683f577 --- /dev/null +++ b/Lido/src/main/java/org/example/model/User.java @@ -0,0 +1,42 @@ +package org.example.model; + + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import jakarta.persistence.*; +import lombok.*; +import org.hibernate.annotations.CreationTimestamp; + +import java.time.Instant; +import java.util.UUID; + +@Entity +@Table(name = "users") +@Setter +@Getter +@AllArgsConstructor +@NoArgsConstructor +@Builder +@JsonIgnoreProperties({"hibernateLazyInitializer", "handler"}) +public class User { + @Id + @GeneratedValue(strategy = GenerationType.UUID) + private UUID id; + + @Column(nullable = false, unique = true, length = 64) + private String username; + + @Column(name = "display_name", nullable = false, length = 128) + @JsonProperty("display_name") + private String displayName; + + @JsonIgnore + @Column(name = "password") + private String password; + + @CreationTimestamp + @Column(name = "created_at", nullable = false, updatable = false) + @JsonProperty("created_at") + private Instant createdAt; +} diff --git a/Lido/src/main/java/org/example/repository/ChatMemberRepository.java b/Lido/src/main/java/org/example/repository/ChatMemberRepository.java new file mode 100644 index 00000000..acfc8a29 --- /dev/null +++ b/Lido/src/main/java/org/example/repository/ChatMemberRepository.java @@ -0,0 +1,14 @@ +package org.example.repository; + +import org.example.model.ChatMember; +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +public interface ChatMemberRepository extends JpaRepository { + List findByUserId(UUID userId); + List findByChatId(UUID chatId); + boolean existsByChatIdAndUserId(UUID chatId, UUID userId); +} diff --git a/Lido/src/main/java/org/example/repository/ChatRepository.java b/Lido/src/main/java/org/example/repository/ChatRepository.java new file mode 100644 index 00000000..bc601a66 --- /dev/null +++ b/Lido/src/main/java/org/example/repository/ChatRepository.java @@ -0,0 +1,10 @@ +package org.example.repository; + +import org.example.model.Chat; +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.UUID; + +public interface ChatRepository extends JpaRepository { + +} diff --git a/Lido/src/main/java/org/example/repository/MessageRepository.java b/Lido/src/main/java/org/example/repository/MessageRepository.java new file mode 100644 index 00000000..702a75e8 --- /dev/null +++ b/Lido/src/main/java/org/example/repository/MessageRepository.java @@ -0,0 +1,31 @@ +package org.example.repository; + +import org.example.model.Message; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; +import org.springframework.data.domain.Pageable; + +import java.time.Instant; +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +public interface MessageRepository extends JpaRepository { + List findByChatIdOrderByCreatedAtDescIdDesc(UUID chatId, Pageable pageable); + + @Query(""" + SELECT m FROM Message m + WHERE m.chatId = :chatId + AND (m.createdAt < :createdAt + OR (m.createdAt = :createdAt AND m.id < :id)) + ORDER BY m.createdAt DESC, m.id DESC + """) + List findNextPage( + @Param("chatId") UUID chatId, + @Param("createdAt") Instant createdAt, + @Param("id") UUID id, + Pageable pageable + ); + Optional findByIdAndChatId(UUID id, UUID chatId); +} diff --git a/Lido/src/main/java/org/example/repository/SessionRepository.java b/Lido/src/main/java/org/example/repository/SessionRepository.java new file mode 100644 index 00000000..86ab2a21 --- /dev/null +++ b/Lido/src/main/java/org/example/repository/SessionRepository.java @@ -0,0 +1,14 @@ +package org.example.repository; + +import org.example.model.Session; +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +public interface SessionRepository extends JpaRepository { + Optional findByToken(String token); + void deleteByUserId(UUID userId); + List findByUserIdOrderByCreatedAtDesc(UUID userId); +} diff --git a/Lido/src/main/java/org/example/repository/UserRepository.java b/Lido/src/main/java/org/example/repository/UserRepository.java new file mode 100644 index 00000000..d17b4c02 --- /dev/null +++ b/Lido/src/main/java/org/example/repository/UserRepository.java @@ -0,0 +1,12 @@ +package org.example.repository; + +import org.example.model.User; +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.Optional; +import java.util.UUID; + +public interface UserRepository extends JpaRepository { + boolean existsByUsername(String username); + Optional findByUsername(String username); +} diff --git a/Lido/src/main/java/org/example/service/AuthService.java b/Lido/src/main/java/org/example/service/AuthService.java new file mode 100644 index 00000000..55a471f7 --- /dev/null +++ b/Lido/src/main/java/org/example/service/AuthService.java @@ -0,0 +1,147 @@ +package org.example.service; + +import org.example.config.TokenHasher; +import org.example.dto.response.SessionInfoResponse; +import org.example.dto.response.SessionResponse; +import org.example.dto.response.UserResponse; +import org.example.exception.UnauthorizedException; +import org.example.model.Session; +import org.example.model.User; +import org.example.repository.SessionRepository; +import org.example.repository.UserRepository; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.security.crypto.password.PasswordEncoder; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.time.Instant; +import java.util.List; +import java.util.Optional; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; + +@Service +public class AuthService { + private final UserRepository userRepository; + private final SessionRepository sessionRepository; + private final PasswordEncoder passwordEncoder; + private final UserService userService; + private final CacheService cacheService; + private final ConcurrentHashMap locks = new ConcurrentHashMap<>(); + + @Value("${app.session-ttl-seconds:604800}") + private long sessionTtlSeconds; + + public AuthService( + UserRepository userRepository, + SessionRepository sessionRepository, + PasswordEncoder passwordEncoder, + UserService userService, + CacheService cacheService + ) { + this.userRepository = userRepository; + this.sessionRepository = sessionRepository; + this.passwordEncoder = passwordEncoder; + this.userService = userService; + this.cacheService = cacheService; + } + + @Transactional + public SessionResponse login(String username, String rawPassword) { + User user = userRepository.findByUsername(username) + .orElseThrow(() -> new UnauthorizedException("Unauthorized")); + + if (user.getPassword() == null + || !passwordEncoder.matches(rawPassword, user.getPassword())) { + throw new UnauthorizedException("Unauthorized"); + } + + String rawToken = TokenHasher.newRawToken(); + Instant expiresAt = Instant.now().plusSeconds(sessionTtlSeconds); + + Session session = Session.builder() + .userId(user.getId()) + .token(TokenHasher.sha256(rawToken)) + .expiresAt(expiresAt) + .createdAt(Instant.now()) + .build(); + sessionRepository.save(session); + cacheService.put(session.getToken(), user.getId(), expiresAt); + + return SessionResponse.builder() + .token(rawToken) + .tokenType("Bearer") + .expiresAt(expiresAt) + .user(UserResponse.builder() + .id(user.getId()) + .username(user.getUsername()) + .displayName(user.getDisplayName()) + .createdAt(user.getCreatedAt()) + .build()) + .build(); + } + + @Transactional + public void logout(String rawToken){ + if (rawToken == null || rawToken.isBlank()){ + return; + } + sessionRepository.findByToken(TokenHasher.sha256(rawToken)) + .ifPresent(s -> { + s.setRevokedAt(Instant.now()); + sessionRepository.save(s); + }); + } + + @Transactional + public void logoutCurrent(String rawToken) { + String tokenHash = TokenHasher.sha256(rawToken); + var session = sessionRepository + .findByToken(tokenHash) + .filter(s -> s.isActive(Instant.now())) + .orElseThrow(() -> new UnauthorizedException("Unauthorized")); + + session.setRevokedAt(Instant.now()); + sessionRepository.save(session); + cacheService.deleteSession(tokenHash); + } + + + public Optional resolveUserByBearer(String rawToken) { + String hash = TokenHasher.sha256(rawToken); + + Optional cached = cacheService.get(hash); + if (cached.isPresent()) { + return userRepository.findById(cached.get()); + } + + Object lock = locks.computeIfAbsent(hash, h -> new Object()); + try { + synchronized (lock) { + cached = cacheService.get(hash); + if (cached.isPresent()) { + return userRepository.findById(cached.get()); + } + return resolveUserByBearer(hash); + } + } finally { + locks.remove(hash, lock); + } + } + + @Transactional(readOnly = true) + public List listSessionsForCurrentUser() { + User user = userService.getCurrentUser(); + Instant now = Instant.now(); + return sessionRepository.findByUserIdOrderByCreatedAtDesc(user.getId()) + .stream() + .map(s -> SessionInfoResponse.builder() + .id(s.getId()) + .createdAt(s.getCreatedAt()) + .expiresAt(s.getExpiresAt()) + .revokedAt(s.getRevokedAt()) + .active(s.isActive(now)) + .build()) + .toList(); + } +} diff --git a/Lido/src/main/java/org/example/service/CacheService.java b/Lido/src/main/java/org/example/service/CacheService.java new file mode 100644 index 00000000..a407a6a4 --- /dev/null +++ b/Lido/src/main/java/org/example/service/CacheService.java @@ -0,0 +1,62 @@ +package org.example.service; + + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.data.redis.core.StringRedisTemplate; +import org.springframework.stereotype.Service; + +import java.time.Duration; +import java.time.Instant; +import java.util.Optional; +import java.util.UUID; +import java.util.concurrent.TimeUnit; + +@Service +@Slf4j +@RequiredArgsConstructor +public class CacheService { + + private static final String PREFIX = "session:"; + private final StringRedisTemplate redis; + + public void put(String token, UUID userId, Instant expiresAt){ + long ttlSec = Duration.between(Instant.now(), expiresAt).getSeconds(); + if (ttlSec <= 0){ + return; + } + try { + redis.opsForValue().set( + PREFIX + token, + userId.toString(), + ttlSec, + TimeUnit.SECONDS + ); + } catch (Exception e){ + log.warn("Сессия не попала в Redis"); + } + } + + public Optional get(String token){ + try { + String v = redis.opsForValue().get(PREFIX + token); + if (v == null || v.isBlank()){ + return Optional.empty(); + } + return Optional.of(UUID.fromString(v)); + } catch (Exception e){ + log.warn("Сессии нет в Redis"); + return Optional.empty(); + } + } + + public void deleteSession(String token){ + try { + redis.delete(PREFIX + token); + } catch (Exception e){ + log.warn("Сессия не удалена в Redis"); + } + } + + +} diff --git a/Lido/src/main/java/org/example/service/ChatService.java b/Lido/src/main/java/org/example/service/ChatService.java new file mode 100644 index 00000000..9d4ba312 --- /dev/null +++ b/Lido/src/main/java/org/example/service/ChatService.java @@ -0,0 +1,157 @@ +package org.example.service; + +import lombok.RequiredArgsConstructor; +import org.example.dto.ChatPage; +import org.example.dto.create.CreateChatDto; +import org.example.dto.response.ChatResponse; +import org.example.dto.update.UpdateChatDto; +import org.example.exception.NotFoundException; +import org.example.model.Chat; +import org.example.model.ChatMember; +import org.example.model.User; +import org.example.repository.ChatMemberRepository; +import org.example.repository.ChatRepository; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +@Service +@RequiredArgsConstructor +public class ChatService { + + private final ChatRepository chatRepository; + private final ChatMemberRepository chatMemberRepository; + private final UserService userService; + + @Transactional + public ChatResponse createChat(CreateChatDto dto) { + User currentUser = userService.getCurrentUser(); + UUID currentId = currentUser.getId(); + + List memberIds = dto.getMemberIds().stream() + .distinct() + .toList(); + + if (!memberIds.contains(currentId)) { + throw new IllegalArgumentException( + "Создатель чата должен входить в список участников (member_ids)"); + } + + for (UUID memberId : memberIds) { + if (!userService.exists(memberId)) { + throw new NotFoundException("Пользователь с ID " + memberId + " не найден"); + } + } + + Chat chat = chatRepository.save( + Chat.builder() + .title(dto.getTitle()) + .build() + ); + + for (UUID memberId : memberIds) { + chatMemberRepository.save( + ChatMember.builder() + .chatId(chat.getId()) + .userId(memberId) + .build() + ); + } + + return toResponse(chat.getId()); + } + + @Transactional(readOnly = true) + public ChatResponse getChatById(UUID chatId) { + requireMember(chatId); + return toResponse(chatId); + } + + @Transactional(readOnly = true) + public ChatResponse getChatById(String chatId) { + return getChatById(parseUuid(chatId)); + } + + @Transactional(readOnly = true) + public ChatPage getChatsForCurrentUser(int limit) { + UUID userId = userService.getCurrentUser().getId(); + List items = new ArrayList<>(); + + for (ChatMember membership : chatMemberRepository.findByUserId(userId)) { + if (items.size() >= limit) { + break; + } + chatRepository.findById(membership.getChatId()) + .ifPresent(chat -> items.add(toResponse(chat.getId()))); + } + return new ChatPage(items, null); + } + + @Transactional + public ChatResponse updateChat(UUID id, UpdateChatDto object) { + requireMember(id); + Chat chat = chatRepository.findById(id) + .orElseThrow(() -> new NotFoundException("Чат не найден")); + chat.setTitle(object.getTitle()); + chatRepository.save(chat); + return toResponse(id); + } + + @Transactional + public ChatResponse updateChat(String id, UpdateChatDto object) { + return updateChat(parseUuid(id), object); + } + + @Transactional + public void deleteChat(UUID id) { + requireMember(id); + chatRepository.deleteById(id); + } + + @Transactional + public void deleteChat(String id) { + deleteChat(parseUuid(id)); + } + + /** Для MessageService: текущий user — участник, иначе 404 */ + @Transactional(readOnly = true) + public void requireMember(UUID chatId) { + User currentUser = userService.getCurrentUser(); + if (!chatRepository.existsById(chatId) + || !chatMemberRepository.existsByChatIdAndUserId(chatId, currentUser.getId())) { + throw new NotFoundException("Чат не найден"); + } + } + + @Transactional(readOnly = true) + public boolean isMember(UUID chatId, UUID userId) { + return chatMemberRepository.existsByChatIdAndUserId(chatId, userId); + } + + private ChatResponse toResponse(UUID chatId) { + Chat chat = chatRepository.findById(chatId) + .orElseThrow(() -> new NotFoundException("Чат не найден")); + + List ids = chatMemberRepository.findByChatId(chatId).stream() + .map(ChatMember::getUserId) + .toList(); + + return ChatResponse.builder() + .id(chat.getId()) + .title(chat.getTitle()) + .memberIds(ids) + .createdAt(chat.getCreatedAt()) + .build(); + } + + private static UUID parseUuid(String id) { + try { + return UUID.fromString(id); + } catch (IllegalArgumentException e) { + throw new NotFoundException("Чат не найден"); + } + } +} \ No newline at end of file diff --git a/Lido/src/main/java/org/example/service/MessageService.java b/Lido/src/main/java/org/example/service/MessageService.java new file mode 100644 index 00000000..21ed57a9 --- /dev/null +++ b/Lido/src/main/java/org/example/service/MessageService.java @@ -0,0 +1,151 @@ +package org.example.service; + +import lombok.RequiredArgsConstructor; +import org.example.dto.MessagePage; +import org.example.dto.create.CreateMessageDto; +import org.example.dto.update.UpdateMessageDto; +import org.example.exception.ForbiddenException; +import org.example.exception.NotFoundException; +import org.example.model.Message; +import org.example.repository.MessageRepository; +import org.springframework.data.domain.PageRequest; +import org.springframework.data.domain.Pageable; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.time.Instant; +import java.util.List; +import java.util.UUID; + +@Service +@RequiredArgsConstructor +public class MessageService { + + private final MessageRepository messageRepository; + private final ChatService chatService; + + @Transactional + public Message sendMessage(UUID chatId, UUID senderId, CreateMessageDto messageObject) { + chatService.requireMember(chatId); + if (!chatService.isMember(chatId, senderId)){ + throw new ForbiddenException("Пользователь не является участником чата"); + } + + Message message = Message.builder() + .chatId(chatId) + .senderId(senderId) + .text(messageObject.getText()) + .createdAt(Instant.now()) + .build(); + + return messageRepository.save(message); + } + + + @Transactional(readOnly = true) + public MessagePage getMessage(UUID chatId, UUID userId, String cursor, int limit) { + if (limit < 1) { + throw new IllegalArgumentException("Лимит должен быть больше 0"); + } + + chatService.requireMember(chatId); + if (!chatService.isMember(chatId, userId)) { + throw new NotFoundException("Чат не найден"); + } + + Pageable pageable = PageRequest.of(0, limit); + List items; + + if (cursor == null || cursor.isBlank()) { + items = messageRepository.findByChatIdOrderByCreatedAtDescIdDesc(chatId, pageable); + } else { + UUID cursorId; + try { + cursorId = UUID.fromString(cursor.trim()); + } catch (IllegalArgumentException e) { + throw new IllegalArgumentException("Invalid cursor"); + } + + Message cursorMsg = messageRepository.findByIdAndChatId(cursorId, chatId) + .orElse(null); + + if (cursorMsg == null) { + throw new IllegalArgumentException("Invalid cursor"); + } + + items = messageRepository.findNextPage( + chatId, + cursorMsg.getCreatedAt(), + cursorMsg.getId(), + pageable + ); + } + + String nextCursor = null; + if (items.size() == limit && !items.isEmpty()) { + nextCursor = items.get(items.size() - 1).getId().toString(); + } + + return new MessagePage(items, nextCursor); + } + + @Transactional(readOnly = true) + public MessagePage getMessage(String chatId, String userId, String cursor, int limit){ + return getMessage(parseUuid(chatId, true), parseUuid(userId, false), cursor, limit); + } + + @Transactional + public Message updateMessage(UUID chatId, UUID messageId, UUID userId, UpdateMessageDto object) { + chatService.requireMember(chatId); + Message message = messageRepository.findByIdAndChatId(messageId, chatId) + .orElseThrow(() -> new NotFoundException("Сообщение не найден")); + if (!message.getSenderId().equals(userId)){ + throw new ForbiddenException("Вы не можете редактировать чужие сообщения"); + } + message.setText(object.getText()); + return messageRepository.save(message); + } + + @Transactional + public Message updateMessage(String chatId, String messageId, String userId, UpdateMessageDto object) { + return updateMessage( + parseUuid(chatId, true), + parseUuid(messageId, true), + parseUuid(userId, false), + object); + } + + @Transactional + public void deleteMessage(UUID chatId, UUID messageId, UUID userId) { + chatService.getChatById(chatId); + + Message msg = messageRepository.findByIdAndChatId(messageId, chatId) + .orElseThrow(() -> new NotFoundException("Сообщение не найдено")); + + if (!msg.getSenderId().equals(userId)) { + throw new ForbiddenException("Вы не можете удалять сообщения других участников"); + } + messageRepository.delete(msg); + } + + @Transactional + public void deleteMessage(String chatId, String messageId, String userId) { + deleteMessage( + parseUuid(chatId, true), + parseUuid(messageId, true), + parseUuid(userId, false) + ); + } + + + private static UUID parseUuid(String value, boolean notFoundOnBad) { + try { + return UUID.fromString(value.trim()); + } catch (Exception e) { + if (notFoundOnBad) { + throw new NotFoundException("Не найдено"); + } + throw new IllegalArgumentException("Invalid id"); + } + } +} \ No newline at end of file diff --git a/Lido/src/main/java/org/example/service/UserService.java b/Lido/src/main/java/org/example/service/UserService.java new file mode 100644 index 00000000..f906e9ed --- /dev/null +++ b/Lido/src/main/java/org/example/service/UserService.java @@ -0,0 +1,106 @@ +package org.example.service; + +import lombok.RequiredArgsConstructor; +import org.example.config.UserContext; +import org.example.dto.create.CreateUserDto; +import org.example.dto.update.UpdateUserDto; +import org.example.exception.NotFoundException; +import org.example.exception.UnauthorizedException; +import org.example.exception.UserAlreadyExistsException; +import org.example.model.User; +import org.example.repository.UserRepository; +import org.springframework.dao.DataIntegrityViolationException; +import org.springframework.security.crypto.password.PasswordEncoder; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.UUID; + +@Service +@RequiredArgsConstructor +public class UserService { + + private final UserRepository userRepository; + private final PasswordEncoder passwordEncoder; + + @Transactional + public User createUser(CreateUserDto userObject) { + if (userRepository.existsByUsername(userObject.getUsername())) { + throw new UserAlreadyExistsException("Пользователь с таким username уже существует: " + userObject.getUsername()); + } + try { + User user = User.builder() + .username(userObject.getUsername()) + .displayName(userObject.getDisplayName()) + .password(passwordEncoder.encode(userObject.getPassword())) + .build(); + return userRepository.save(user); + } catch (DataIntegrityViolationException e){ + throw new UserAlreadyExistsException( + "Пользователь с таким username уже есть: " + userObject.getUsername()); + } + } + + @Transactional(readOnly = true) + public User getCurrentUser() { + User user = UserContext.getCurrentUser(); + if (user == null) { + throw new UnauthorizedException("Unauthorized"); + } + return user; + } + + @Transactional(readOnly = true) + public User getUserById(UUID id) { + return userRepository.findById(id) + .orElseThrow(() -> new NotFoundException("Пользователь с id: " + id + " не найден.")); + } + + @Transactional + public User updateUser(UUID id, UpdateUserDto updateObject){ + User existing = getUserById(id); + existing.setDisplayName(updateObject.getDisplayName()); + return userRepository.save(existing); + } + + @Transactional + public User updateUser(String id, UpdateUserDto updateObject) { + return updateUser(parseUuid(id), updateObject); + } + + @Transactional + public void deleteUser(UUID id) { + if (!userRepository.existsById(id)) { + throw new NotFoundException("Пользователь с id: " + id + " не найден"); + } + userRepository.deleteById(id); + } + + @Transactional + public void deleteUser(String id) { + deleteUser(parseUuid(id)); + } + + @Transactional(readOnly = true) + public boolean exists(UUID id) { + return userRepository.existsById(id); + } + + + @Transactional(readOnly = true) + public boolean exists(String id) { + try { + return exists(parseUuid(id)); + }catch (IllegalArgumentException e) { + return false; + } + } + + private static UUID parseUuid(String id) { + try { + return UUID.fromString(id); + } catch (IllegalArgumentException e) { + throw new NotFoundException("Пользователь с id: " + id + " не найден"); + } + } +} \ No newline at end of file diff --git a/Lido/src/main/resources/application.yml b/Lido/src/main/resources/application.yml new file mode 100644 index 00000000..7c68dbc2 --- /dev/null +++ b/Lido/src/main/resources/application.yml @@ -0,0 +1,68 @@ +spring: + jackson: + property-naming-strategy: SNAKE_CASE + lifecycle: + timeout-per-shutdown-cycle=10s: + + spring: + datasource: + url: ${SPRING_DATASOURCE_URL:jdbc:postgresql://localhost:5433/lido_db} + username: ${SPRING_DATASOURCE_USERNAME:user} + password: ${SPRING_DATASOURCE_PASSWORD:user} + hikari: + maximum-pool-size: 10 + minimum-idle: 2 + connection-timeout: 3000 + idle-timeout: 600000 + max-lifetime: 1800000 + validation-timeout: 2000 + jpa: + open-in-view: false + hibernate: + ddl-auto: validate + properties: + hibernate: + jdbc: + time_zone: UTC + flyway: + enabled: true + locations: classpath:db/migration + redis: + host: ${SPRING_DATA_REDIS_HOST:localhost} + port: ${SPRING_DATA_REDIS_PORT:6379} + timeout: 300ms + connect-timeout: 300ms + lettuce: + shutdown-timeout: 100ms + repositories: + enabled: false + + server: + port: ${SERVER_PORT:8080} + +app: + session-ttl-seconds: ${SESSION_TTL_SECONDS:604800} + +logging: + pattern: + console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} [req_id: %X{X-Request-Id}] - %msg%n" + level: + root=INFO: + org: + springframework: + web=DEBUG: + web: + filter: + CommonsRequestLoggingFilter=DEBUG: + :servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver: DEBUG + +server: + shutdown=graceful: + +management: + endpoints: + web: + exposure: + include=health: + health: + show-details=always: diff --git a/Lido/src/main/resources/db/migration/V1__init_messanger.sql b/Lido/src/main/resources/db/migration/V1__init_messanger.sql new file mode 100644 index 00000000..297a121f --- /dev/null +++ b/Lido/src/main/resources/db/migration/V1__init_messanger.sql @@ -0,0 +1,35 @@ +CREATE TABLE users ( + id UUID PRIMARY KEY, + username VARCHAR(64) NOT NULL, + display_name VARCHAR(128) NOT NULL, + password VARCHAR(255), + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + CONSTRAINT uq_users_username UNIQUE (username) +); + +CREATE TABLE chats ( + id UUID PRIMARY KEY, + title VARCHAR(32) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + joined_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX idx_chat_members_user ON chat_members (user_id); + +CREATE TABLE messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id), + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + CONSTRAINT chk_messages_text_nonempty CHECK (char_length(trim(text)) > 0) +); + +CREATE INDEX idx_messages_chat_created_id + ON messages (chat_id, created_at DESC, id DESC); \ No newline at end of file diff --git a/Lido/src/main/resources/db/migration/V2__auth_sessions.sql b/Lido/src/main/resources/db/migration/V2__auth_sessions.sql new file mode 100644 index 00000000..7c52293f --- /dev/null +++ b/Lido/src/main/resources/db/migration/V2__auth_sessions.sql @@ -0,0 +1,12 @@ +CREATE TABLE sessions ( + id UUID PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + token VARCHAR(64) NOT NULL, + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + revoked_at TIMESTAMPTZ NULL, + CONSTRAINT uq_sessions_token_hash UNIQUE (token) +); + +CREATE INDEX idx_sessions_user_id ON sessions (user_id); +CREATE INDEX idx_sessions_expires_at ON sessions (expires_at); \ No newline at end of file diff --git a/Lido/src/test/java/org/example/ApiIntegrationTest.java b/Lido/src/test/java/org/example/ApiIntegrationTest.java new file mode 100644 index 00000000..eea76b64 --- /dev/null +++ b/Lido/src/test/java/org/example/ApiIntegrationTest.java @@ -0,0 +1,123 @@ +package org.example; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.http.MediaType; +import org.springframework.test.web.servlet.MockMvc; + +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +@SpringBootTest +@AutoConfigureMockMvc +public class ApiIntegrationTest { + + @Autowired + private MockMvc mockMvc; + @Test + @DisplayName("400 1. Неверный / битый JSON должен возвращать 400 Bad Request") + void shouldReturn400ForMalformedJson() throws Exception { + String malformedJson = "{\"username\": \"bad_json\", \"display_name\":}"; + + mockMvc.perform(post("/api/v1/users") + .contentType(MediaType.APPLICATION_JSON) + .content(malformedJson)) + .andExpect(status().isBadRequest()); + } + + @Test + @DisplayName("400 2. Валидация: пустой username должен возвращать 400 Bad Request") + void shouldReturn400ForEmptyUsername() throws Exception { + String invalidJson = "{\"username\": \"\", \"display_name\": \"User\"}"; + + mockMvc.perform(post("/api/v1/users") + .contentType(MediaType.APPLICATION_JSON) + .content(invalidJson)) + .andExpect(status().isBadRequest()); + } + + @Test + @DisplayName("404 3. Неучастник чата получает 404 (чат скрыт)") + void shouldReturn404WhenUserIsNotChatMember() throws Exception { + String aliceJson = mockMvc.perform(post("/api/v1/users") + .contentType(MediaType.APPLICATION_JSON) + .content("{\"username\": \"alice_test\", \"display_name\": \"Alice\"}")) + .andExpect(status().isCreated()) + .andReturn().getResponse().getContentAsString(); + String aliceId = extractId(aliceJson); + + String bobJson = mockMvc.perform(post("/api/v1/users") + .contentType(MediaType.APPLICATION_JSON) + .content("{\"username\": \"bob_test\", \"display_name\": \"Bob\"}")) + .andExpect(status().isCreated()) + .andReturn().getResponse().getContentAsString(); + String bobId = extractId(bobJson); + + String spyJson = mockMvc.perform(post("/api/v1/users") + .contentType(MediaType.APPLICATION_JSON) + .content("{\"username\": \"spy_test\", \"display_name\": \"Spy\"}")) + .andExpect(status().isCreated()) + .andReturn().getResponse().getContentAsString(); + String spyId = extractId(spyJson); + + String chatJson = String.format( + "{\"title\":\"Private\", \"member_ids\":[\"%s\",\"%s\"]}", aliceId, bobId); + + String chat = mockMvc.perform(post("/api/v1/chats") + .header("X-User-Id", aliceId) // ← обязательно! + .contentType(MediaType.APPLICATION_JSON) + .content(chatJson)) + .andExpect(status().isCreated()) + .andReturn().getResponse().getContentAsString(); + String chatId = extractId(chat); + + mockMvc.perform(post("/api/v1/chats/" + chatId + "/messages") + .header("X-User-Id", spyId) + .contentType(MediaType.APPLICATION_JSON) + .content("{\"text\": \"Secret message\"}")) + .andExpect(status().isNotFound()); + } + + @Test + @DisplayName("200 4. Пагинация: получение ограниченного числа сообщений по limit") + void shouldPaginateMessagesWithLimit() throws Exception { + String userJson = mockMvc.perform(post("/api/v1/users") + .contentType(MediaType.APPLICATION_JSON) + .content("{\"username\": \"paginator\", \"display_name\": \"Paginator\"}")) + .andExpect(status().isCreated()) + .andReturn().getResponse().getContentAsString(); + String userId = extractId(userJson); + + String chat = mockMvc.perform(post("/api/v1/chats") + .header("X-User-Id", userId) + .contentType(MediaType.APPLICATION_JSON) + .content(String.format( + "{\"title\":\"Paginated Chat\", \"member_ids\":[\"%s\"]}", userId))) + .andExpect(status().isCreated()) + .andReturn().getResponse().getContentAsString(); + String chatId = extractId(chat); + + for (int i = 1; i <= 3; i++) { + mockMvc.perform(post("/api/v1/chats/" + chatId + "/messages") + .header("X-User-Id", userId) + .contentType(MediaType.APPLICATION_JSON) + .content("{\"text\": \"Msg " + i + "\"}")) + .andExpect(status().isCreated()); + } + mockMvc.perform(get("/api/v1/chats/" + chatId + "/messages") + .param("limit", "2") + .header("X-User-Id", userId)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.items.length()").value(2)) + .andExpect(jsonPath("$.next_cursor").isNotEmpty()); + } + + private String extractId(String json) { + return json.split("\"id\":\"")[1].split("\"")[0]; + } +} \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index e42f2b05..b79c350f 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,130 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: **Гуреев Дмитрий, БПИ2301** +- Целевая оценка; выбранный трек 5: **5, Трек 1 — согласованность кэша (cache stampede / single-flight)** - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники, библиотеки и помощь ИИ: + - Spring Boot, Spring Data JPA, Flyway, PostgreSQL 16, Redis 7, Docker Compose + - spring-boot-starter-data-redis (Lettuce), spring-security-crypto (BCrypt) + - Документация Spring / PostgreSQL / Redis / k6 (при необходимости) + - Помощь ИИ: разбор контракта, AuthFilter/сессии, Redis-кэш, single-flight ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +**Версии:** Java 22 (Temurin), PostgreSQL 16-alpine, Redis 7-alpine, Docker Compose. + +**Prerequisites:** Docker, Docker Compose, `make`, Python 3, `curl`. + +```bash +git clone https://gitea.privcloud.tech/Dmitry/mtusi2026lab2 +cd mtusi2026lab2 +cd Lido +docker compose up -d --build +# дождаться healthy: db, redis, api +curl -sf http://localhost:8080/health/live || curl -sf http://localhost:8080/actuator/health + +cd .. +make test BASE_URL=http://localhost:8080 +make test-persistence ACTION_SCRIPT=scripts/restart.sh +``` + +Миграции Flyway применяются при старте API (`ddl-auto: validate`). + +**Остановка (данные на volumes сохраняются):** +```bash +cd Lido && docker compose stop +``` + +**Намеренное удаление учебных данных (volumes):** +```bash +cd Lido && docker compose down -v +``` +Не использовать `down -v` в `scripts/restart.sh` — только `restart` без удаления volumes. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +**Процессы / хранилища** + +| Компонент | Роль | +|-----------|------| +| API (Spring Boot) | REST `/api/v1/*`, AuthFilter (только Bearer), сессии | +| PostgreSQL | Источник истины: users, chats, chat_members, messages, sessions | +| Redis | Кэш активных сессий: `session: → userId`, TTL ≈ expires_at | + +**Источник истины сессий:** PostgreSQL (`sessions`: hash токена, expires_at, revoked_at). +**Redis:** write-through при login, read-through при /me, DEL при logout; при miss/ошибке Redis — чтение из PG. + +**Транзакционные границы:** `@Transactional` на createChat (chat + members), login (insert session), logout (revoke). Регистрация пользователя с обработкой unique violation → 409. + +**Из Lab1:** контракт чатов/сообщений/users, X-Request-Id, курсор сообщений. +**В Lab2:** PostgreSQL + Flyway, пароль KDF (BCrypt), Basic → opaque Bearer, сессии в БД, Compose, Redis-кэш, keyset-пагинация сообщений по индексу `(chat_id, created_at DESC, id DESC)`. + +**Конфиг:** `SESSION_TTL_SECONDS`, `SPRING_DATASOURCE_*`, `SPRING_DATA_REDIS_HOST/PORT` — соответствуют `.env.example` / compose environment (секреты не в git). + +**Трек 1:** single-flight (`ConcurrentHashMap` + `synchronized` на tokenHash) в `resolveUserByBearer`, чтобы после холодного кэша не было cache stampede в PG. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| ---------------------------------------- | ----------------------------------------------------- | ---------------------------------------------------------- | -------------------------- | +| Публичный smoke Lab2 | `make test BASE_URL=http://localhost:8080` | PASS: lab2 public API scenario | вывод make test | +| Postgres + миграции + CRUD | Flyway at start; curl users/chats/messages | таблицы users/chats/messages/sessions; API 2xx | логи Flyway, psql `\dt` | +| Auth: register, Basic, Bearer, logout | POST /users; POST /auth/sessions; GET /me; DELETE ... | 201 session; me 200; logout 204; повтор me 401 | curl -i | +| Compose + volumes | `docker compose up -d` | db, redis, api healthy | `docker compose ps` | +| Persistence hook | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS: data and session preserved | вывод make; scripts/restart.sh | +| Redis кэш сессий | login → KEYS session:*; stop redis → login/me | ключи после login; без Redis 201/200, без token 401 | redis-cli, curl | +| Keyset + индекс сообщений | getMessage Pageable; EXPLAIN на ≥10k | Index Scan по idx_messages_chat_created_id | EXPLAIN в этом отчёте | +| Гонка username / rollback chat | параллельный POST /users; chat с несуществующим member | 201+409; чата-сироты нет | curl, psql count | +| Трек 1: stampede / single-flight | FLUSHDB + 30× GET /me; read-after-write; restart redis | см. раздел «Эксперименты» | lat_before/after, curl | + + +`scripts/restart.sh` перезапускает сервисы Compose в `Lido/` (`db`, `api`, `redis`) **без** `down -v`, ждёт готовности HTTP. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +**Гипотеза (Трек 1):** после очистки Redis concurrent GET /me с одним Bearer вызывают stampede (много одинаковых SQL). Single-flight на tokenHash снижает число загрузок из PG. Latency хвоста может не упасть из‑за ожидания на lock. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +**Стенд:** Docker Compose на локальной машине (API + PG + Redis на одном хосте). Ограничение: один инстанс API; in-memory locks не для кластера. + +**Профиль:** 30 параллельных `curl` GET /users/me, один opaque Bearer; перед серией `redis-cli FLUSHDB`. Повторы: 1 серия до и 1 после деплоя single-flight. + +**Latency (5 max time_total, секунды):** + +| | max хвост | +|--|-----------| +| До single-flight | 0.052–0.062 | +| После | 0.106–0.118 | + +Интерпретация: после защиты часть запросов сериализуется на lock при холодном кэше; целевая метрика stampede — число SQL, не p95. SQL-счётчик при необходимости снимается через `show-sql` / логи за окно нагрузки. + +**Read-after-write:** POST /auth/sessions → сразу GET /users/me с новым token → **200** (user track1). + +**Рестарт кэша:** `docker compose restart redis` → GET /me с тем же token → **200** (восстановление из PostgreSQL). + +**Объём данных для индекса:** ≥10 000 сообщений в одном чате; EXPLAIN (ANALYZE, BUFFERS) — Index Scan по `idx_messages_chat_created_id`. + + +| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +| ------------------------ | ------------------------------------ | -------------------------------------------------- | ------------------------------------------- | +| FLUSHDB + 30× /me | stampede без защиты | все запросы 200; см. latency до/после | кэш пуст; сессия в PG без потерь | +| Single-flight | меньше параллельных SQL на один hash | защита внедрена; latency хвоста выше (ожидание lock) | — | +| Login → сразу /me | read-after-write 200 | 200 | 0; данные не теряются | +| restart redis | /me 200 из PG | 200 | секунды на healthy Redis; сессии не теряются | +| stop redis | login/me через PG; без token 401 | 201/200/401; с коротким timeout без минутной задержки | —; SoT = PG | +| restart api+db (hook) | session и данные живы | PASS test-persistence | volumes сохранены | +| Неверный пароль | 401 + Basic WWW-Authenticate | 401 | — | +| Logout | 204, затем me 401 | 204 → 401 | сессия revoked в PG + DEL Redis | + + +**Ограничения измерения:** k6/curl и API на одной машине; без отдельного Prometheus; tokens в отчёт не включались. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +**Выдерживается:** рестарт API/БД с volumes; рестарт/очистка Redis при живом PG; logout/expiry; concurrent register → 409; keyset по индексу. + +**Не выдерживается / упрощения:** single-flight только в памяти одного JVM (не multi-instance); нет горизонтального шардирования; Redis down даёт краткий timeout на put/get (не zero-cost); нет полноценного HA PostgreSQL. + +**Подтверждено:** persistence сессий в PG; кэш Redis с fallback; read-after-write; /me после restart Redis; smoke и test-persistence PASS. + +**Гипотеза / на будущее:** явный счётчик SQL до/после stampede; distributed lock (Redis) для нескольких реплик API; вынос single-flight в отдельный модуль метрик. diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..3acba34f --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,20 @@ +#!/bin/sh +set -eu + +ROOT="$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)" +cd "$ROOT/Lido" + +docker compose -f docker-compose.yml restart db api redis + +BASE_URL="${BASE_URL:-http://127.0.0.1:8080}" +i=0 +while [ "$i" -lt 60 ]; do + if curl -sf "$BASE_URL/health/live" >/dev/null 2>&1 \ + || curl -sf "$BASE_URL/actuator/health" >/dev/null 2>&1; then + exit 0 + fi + i=$((i + 1)) + sleep 1 +done +echo "API not ready" >&2 +exit 1 \ No newline at end of file