diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..6d91637 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,26 @@ +FROM maven:3.9.9-eclipse-temurin-21 AS builder +WORKDIR /build + +COPY java/pom.xml . +RUN mvn -B -q dependency:go-offline + + +COPY java/src ./src +RUN mvn -B -q clean package -DskipTests + +FROM eclipse-temurin:21-jre-alpine AS runtime + +RUN addgroup -g 1001 -S appgroup \ + && adduser -u 1001 -S appuser -G appgroup + +WORKDIR /app +COPY --from=builder /build/target/*.jar app.jar +RUN chown -R appuser:appgroup /app + +USER appuser +EXPOSE 8080 + +HEALTHCHECK --interval=30s --timeout=5s --start-period=20s --retries=3 \ + CMD wget -qO- http://localhost:8080/health/live || exit 1 + +ENTRYPOINT ["java", "-XX:MaxRAMPercentage=75.0", "-jar", "/app/app.jar"] \ No newline at end of file diff --git a/Makefile b/Makefile index 5d86d17..3c6b967 100644 --- a/Makefile +++ b/Makefile @@ -15,6 +15,9 @@ check: validate: $(PYTHON) scripts/validate_openapi.py +java-test: + cd java && mvnw.cmd tes + test: $(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS) diff --git a/compose.yml b/compose.yml new file mode 100644 index 0000000..6fa1b64 --- /dev/null +++ b/compose.yml @@ -0,0 +1,96 @@ +services: + postgres: + image: postgres:16.6-alpine + environment: + POSTGRES_DB: ${POSTGRES_DB:?} + POSTGRES_USER: ${POSTGRES_USER:?} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?} + command: ["postgres", "-c", "max_connections=100", "-c", "shared_buffers=128MB"] + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"] + interval: 2s + timeout: 1s + retries: 30 + cpus: 1.0 + mem_limit: 512m + networks: [data] + redis: + image: redis:7.4.1-alpine + environment: + REDIS_PASSWORD: ${REDIS_PASSWORD:?} + command: ['sh', '-c', 'exec redis-server --requirepass "$$REDIS_PASSWORD" --appendonly yes --appendfsync always --maxmemory 128mb --maxmemory-policy noeviction'] + volumes: + - redis_data:/data + healthcheck: + test: ["CMD-SHELL", "REDISCLI_AUTH=$$REDIS_PASSWORD redis-cli ping | grep -q PONG"] + interval: 2s + timeout: 1s + retries: 30 + cpus: 0.5 + mem_limit: 192m + networks: [data] + migrate: + image: flyway/flyway:10.20.1-alpine + command: ["-connectRetries=30", "migrate"] + environment: + FLYWAY_URL: jdbc:postgresql://postgres:5432/${POSTGRES_DB:?} + FLYWAY_USER: ${POSTGRES_USER:?} + FLYWAY_PASSWORD: ${POSTGRES_PASSWORD:?} + volumes: + - ./java/src/main/resources/db/migration:/flyway/sql:ro + depends_on: + postgres: + condition: service_healthy + cpus: 0.5 + mem_limit: 384m + restart: "no" + networks: [data] + api: + build: . + image: ${APP_IMAGE:-mtusi3-api:local} + environment: + DB_URL: jdbc:postgresql://postgres:5432/${POSTGRES_DB:?} + DB_USERNAME: ${POSTGRES_USER:?} + DB_PASSWORD: ${POSTGRES_PASSWORD:?} + REDIS_HOST: redis + REDIS_PASSWORD: ${REDIS_PASSWORD:?} + DB_POOL_SIZE: ${DB_POOL_SIZE:-8} + FLYWAY_ENABLED: "false" + depends_on: + migrate: + condition: service_completed_successfully + redis: + condition: service_healthy + deploy: + replicas: ${API_REPLICAS:-2} + cpus: ${API_CPUS:-1.0} + mem_limit: ${API_MEMORY:-768m} + stop_grace_period: 20s + healthcheck: + test: ["CMD", "wget", "-qO-", "http://localhost:8080/health/ready"] + interval: 2s + timeout: 2s + start_period: 60s + retries: 3 + networks: [edge, data] + lb: + image: haproxy:3.0.5-alpine + ports: + - "127.0.0.1:${API_PORT:-8080}:8080" + volumes: + - ./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + depends_on: + api: + condition: service_healthy + cpus: 0.5 + mem_limit: 128m + networks: [edge] +volumes: + postgres_data: + redis_data: +networks: + edge: + data: + internal: true diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg new file mode 100644 index 0000000..c080ca7 --- /dev/null +++ b/infra/haproxy.cfg @@ -0,0 +1,33 @@ +global + log stdout format raw local0 + maxconn 2048 +defaults + mode http + log global + option httplog + timeout connect 1s + timeout client 12s + timeout server 10s + timeout check 1s + timeout queue 2s + retries 0 +resolvers docker + nameserver docker 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + hold valid 1s + hold obsolete 1s + hold nx 1s + hold refused 1s + hold timeout 1s +frontend public + bind :8080 + http-request deny if { path_beg /actuator } + default_backend api +backend api + balance roundrobin + option httpchk + http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host api + http-check expect status 200 + server-template node 1-8 api:8080 check inter 1s fastinter 500ms downinter 1s fall 2 rise 2 resolvers docker resolve-prefer ipv4 init-addr libc,none diff --git a/java/.gitignore b/java/.gitignore new file mode 100644 index 0000000..667aaef --- /dev/null +++ b/java/.gitignore @@ -0,0 +1,33 @@ +HELP.md +target/ +.mvn/wrapper/maven-wrapper.jar +!**/src/main/**/target/ +!**/src/test/**/target/ + +### STS ### +.apt_generated +.classpath +.factorypath +.project +.settings +.springBeans +.sts4-cache + +### IntelliJ IDEA ### +.idea +*.iws +*.iml +*.ipr + +### NetBeans ### +/nbproject/private/ +/nbbuild/ +/dist/ +/nbdist/ +/.nb-gradle/ +build/ +!**/src/main/**/build/ +!**/src/test/**/build/ + +### VS Code ### +.vscode/ diff --git a/java/.mvn/wrapper/maven-wrapper.properties b/java/.mvn/wrapper/maven-wrapper.properties new file mode 100644 index 0000000..216df05 --- /dev/null +++ b/java/.mvn/wrapper/maven-wrapper.properties @@ -0,0 +1,3 @@ +wrapperVersion=3.3.4 +distributionType=only-script +distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.16/apache-maven-3.9.16-bin.zip diff --git a/java/mvnw b/java/mvnw new file mode 100644 index 0000000..bd8896b --- /dev/null +++ b/java/mvnw @@ -0,0 +1,295 @@ +#!/bin/sh +# ---------------------------------------------------------------------------- +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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 +# +# http://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. +# ---------------------------------------------------------------------------- + +# ---------------------------------------------------------------------------- +# Apache Maven Wrapper startup batch script, version 3.3.4 +# +# Optional ENV vars +# ----------------- +# JAVA_HOME - location of a JDK home dir, required when download maven via java source +# MVNW_REPOURL - repo url base for downloading maven distribution +# MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven +# MVNW_VERBOSE - true: enable verbose log; debug: trace the mvnw script; others: silence the output +# ---------------------------------------------------------------------------- + +set -euf +[ "${MVNW_VERBOSE-}" != debug ] || set -x + +# OS specific support. +native_path() { printf %s\\n "$1"; } +case "$(uname)" in +CYGWIN* | MINGW*) + [ -z "${JAVA_HOME-}" ] || JAVA_HOME="$(cygpath --unix "$JAVA_HOME")" + native_path() { cygpath --path --windows "$1"; } + ;; +esac + +# set JAVACMD and JAVACCMD +set_java_home() { + # For Cygwin and MinGW, ensure paths are in Unix format before anything is touched + 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" + JAVACCMD="$JAVA_HOME/jre/sh/javac" + else + JAVACMD="$JAVA_HOME/bin/java" + JAVACCMD="$JAVA_HOME/bin/javac" + + if [ ! -x "$JAVACMD" ] || [ ! -x "$JAVACCMD" ]; then + echo "The JAVA_HOME environment variable is not defined correctly, so mvnw cannot run." >&2 + echo "JAVA_HOME is set to \"$JAVA_HOME\", but \"\$JAVA_HOME/bin/java\" or \"\$JAVA_HOME/bin/javac\" does not exist." >&2 + return 1 + fi + fi + else + JAVACMD="$( + 'set' +e + 'unset' -f command 2>/dev/null + 'command' -v java + )" || : + JAVACCMD="$( + 'set' +e + 'unset' -f command 2>/dev/null + 'command' -v javac + )" || : + + if [ ! -x "${JAVACMD-}" ] || [ ! -x "${JAVACCMD-}" ]; then + echo "The java/javac command does not exist in PATH nor is JAVA_HOME set, so mvnw cannot run." >&2 + return 1 + fi + fi +} + +# hash string like Java String::hashCode +hash_string() { + str="${1:-}" h=0 + while [ -n "$str" ]; do + char="${str%"${str#?}"}" + h=$(((h * 31 + $(LC_CTYPE=C printf %d "'$char")) % 4294967296)) + str="${str#?}" + done + printf %x\\n $h +} + +verbose() { :; } +[ "${MVNW_VERBOSE-}" != true ] || verbose() { printf %s\\n "${1-}"; } + +die() { + printf %s\\n "$1" >&2 + exit 1 +} + +trim() { + # MWRAPPER-139: + # Trims trailing and leading whitespace, carriage returns, tabs, and linefeeds. + # Needed for removing poorly interpreted newline sequences when running in more + # exotic environments such as mingw bash on Windows. + printf "%s" "${1}" | tr -d '[:space:]' +} + +scriptDir="$(dirname "$0")" +scriptName="$(basename "$0")" + +# parse distributionUrl and optional distributionSha256Sum, requires .mvn/wrapper/maven-wrapper.properties +while IFS="=" read -r key value; do + case "${key-}" in + distributionUrl) distributionUrl=$(trim "${value-}") ;; + distributionSha256Sum) distributionSha256Sum=$(trim "${value-}") ;; + esac +done <"$scriptDir/.mvn/wrapper/maven-wrapper.properties" +[ -n "${distributionUrl-}" ] || die "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties" + +case "${distributionUrl##*/}" in +maven-mvnd-*bin.*) + MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ + case "${PROCESSOR_ARCHITECTURE-}${PROCESSOR_ARCHITEW6432-}:$(uname -a)" in + *AMD64:CYGWIN* | *AMD64:MINGW*) distributionPlatform=windows-amd64 ;; + :Darwin*x86_64) distributionPlatform=darwin-amd64 ;; + :Darwin*arm64) distributionPlatform=darwin-aarch64 ;; + :Linux*x86_64*) distributionPlatform=linux-amd64 ;; + *) + echo "Cannot detect native platform for mvnd on $(uname)-$(uname -m), use pure java version" >&2 + distributionPlatform=linux-amd64 + ;; + esac + distributionUrl="${distributionUrl%-bin.*}-$distributionPlatform.zip" + ;; +maven-mvnd-*) MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ ;; +*) MVN_CMD="mvn${scriptName#mvnw}" _MVNW_REPO_PATTERN=/org/apache/maven/ ;; +esac + +# apply MVNW_REPOURL and calculate MAVEN_HOME +# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-,maven-mvnd--}/ +[ -z "${MVNW_REPOURL-}" ] || distributionUrl="$MVNW_REPOURL$_MVNW_REPO_PATTERN${distributionUrl#*"$_MVNW_REPO_PATTERN"}" +distributionUrlName="${distributionUrl##*/}" +distributionUrlNameMain="${distributionUrlName%.*}" +distributionUrlNameMain="${distributionUrlNameMain%-bin}" +MAVEN_USER_HOME="${MAVEN_USER_HOME:-${HOME}/.m2}" +MAVEN_HOME="${MAVEN_USER_HOME}/wrapper/dists/${distributionUrlNameMain-}/$(hash_string "$distributionUrl")" + +exec_maven() { + unset MVNW_VERBOSE MVNW_USERNAME MVNW_PASSWORD MVNW_REPOURL || : + exec "$MAVEN_HOME/bin/$MVN_CMD" "$@" || die "cannot exec $MAVEN_HOME/bin/$MVN_CMD" +} + +if [ -d "$MAVEN_HOME" ]; then + verbose "found existing MAVEN_HOME at $MAVEN_HOME" + exec_maven "$@" +fi + +case "${distributionUrl-}" in +*?-bin.zip | *?maven-mvnd-?*-?*.zip) ;; +*) die "distributionUrl is not valid, must match *-bin.zip or maven-mvnd-*.zip, but found '${distributionUrl-}'" ;; +esac + +# prepare tmp dir +if TMP_DOWNLOAD_DIR="$(mktemp -d)" && [ -d "$TMP_DOWNLOAD_DIR" ]; then + clean() { rm -rf -- "$TMP_DOWNLOAD_DIR"; } + trap clean HUP INT TERM EXIT +else + die "cannot create temp dir" +fi + +mkdir -p -- "${MAVEN_HOME%/*}" + +# Download and Install Apache Maven +verbose "Couldn't find MAVEN_HOME, downloading and installing it ..." +verbose "Downloading from: $distributionUrl" +verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName" + +# select .zip or .tar.gz +if ! command -v unzip >/dev/null; then + distributionUrl="${distributionUrl%.zip}.tar.gz" + distributionUrlName="${distributionUrl##*/}" +fi + +# verbose opt +__MVNW_QUIET_WGET=--quiet __MVNW_QUIET_CURL=--silent __MVNW_QUIET_UNZIP=-q __MVNW_QUIET_TAR='' +[ "${MVNW_VERBOSE-}" != true ] || __MVNW_QUIET_WGET='' __MVNW_QUIET_CURL='' __MVNW_QUIET_UNZIP='' __MVNW_QUIET_TAR=v + +# normalize http auth +case "${MVNW_PASSWORD:+has-password}" in +'') MVNW_USERNAME='' MVNW_PASSWORD='' ;; +has-password) [ -n "${MVNW_USERNAME-}" ] || MVNW_USERNAME='' MVNW_PASSWORD='' ;; +esac + +if [ -z "${MVNW_USERNAME-}" ] && command -v wget >/dev/null; then + verbose "Found wget ... using wget" + wget ${__MVNW_QUIET_WGET:+"$__MVNW_QUIET_WGET"} "$distributionUrl" -O "$TMP_DOWNLOAD_DIR/$distributionUrlName" || die "wget: Failed to fetch $distributionUrl" +elif [ -z "${MVNW_USERNAME-}" ] && command -v curl >/dev/null; then + verbose "Found curl ... using curl" + curl ${__MVNW_QUIET_CURL:+"$__MVNW_QUIET_CURL"} -f -L -o "$TMP_DOWNLOAD_DIR/$distributionUrlName" "$distributionUrl" || die "curl: Failed to fetch $distributionUrl" +elif set_java_home; then + verbose "Falling back to use Java to download" + javaSource="$TMP_DOWNLOAD_DIR/Downloader.java" + targetZip="$TMP_DOWNLOAD_DIR/$distributionUrlName" + cat >"$javaSource" <<-END + public class Downloader extends java.net.Authenticator + { + protected java.net.PasswordAuthentication getPasswordAuthentication() + { + return new java.net.PasswordAuthentication( System.getenv( "MVNW_USERNAME" ), System.getenv( "MVNW_PASSWORD" ).toCharArray() ); + } + public static void main( String[] args ) throws Exception + { + setDefault( new Downloader() ); + java.nio.file.Files.copy( java.net.URI.create( args[0] ).toURL().openStream(), java.nio.file.Paths.get( args[1] ).toAbsolutePath().normalize() ); + } + } + END + # For Cygwin/MinGW, switch paths to Windows format before running javac and java + verbose " - Compiling Downloader.java ..." + "$(native_path "$JAVACCMD")" "$(native_path "$javaSource")" || die "Failed to compile Downloader.java" + verbose " - Running Downloader.java ..." + "$(native_path "$JAVACMD")" -cp "$(native_path "$TMP_DOWNLOAD_DIR")" Downloader "$distributionUrl" "$(native_path "$targetZip")" +fi + +# If specified, validate the SHA-256 sum of the Maven distribution zip file +if [ -n "${distributionSha256Sum-}" ]; then + distributionSha256Result=false + if [ "$MVN_CMD" = mvnd.sh ]; then + echo "Checksum validation is not supported for maven-mvnd." >&2 + echo "Please disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2 + exit 1 + elif command -v sha256sum >/dev/null; then + if echo "$distributionSha256Sum $TMP_DOWNLOAD_DIR/$distributionUrlName" | sha256sum -c - >/dev/null 2>&1; then + distributionSha256Result=true + fi + elif command -v shasum >/dev/null; then + if echo "$distributionSha256Sum $TMP_DOWNLOAD_DIR/$distributionUrlName" | shasum -a 256 -c >/dev/null 2>&1; then + distributionSha256Result=true + fi + else + echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2 + echo "Please install either command, or disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2 + exit 1 + fi + if [ $distributionSha256Result = false ]; then + echo "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised." >&2 + echo "If you updated your Maven version, you need to update the specified distributionSha256Sum property." >&2 + exit 1 + fi +fi + +# unzip and move +if command -v unzip >/dev/null; then + unzip ${__MVNW_QUIET_UNZIP:+"$__MVNW_QUIET_UNZIP"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -d "$TMP_DOWNLOAD_DIR" || die "failed to unzip" +else + tar xzf${__MVNW_QUIET_TAR:+"$__MVNW_QUIET_TAR"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -C "$TMP_DOWNLOAD_DIR" || die "failed to untar" +fi + +# Find the actual extracted directory name (handles snapshots where filename != directory name) +actualDistributionDir="" + +# First try the expected directory name (for regular distributions) +if [ -d "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" ]; then + if [ -f "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain/bin/$MVN_CMD" ]; then + actualDistributionDir="$distributionUrlNameMain" + fi +fi + +# If not found, search for any directory with the Maven executable (for snapshots) +if [ -z "$actualDistributionDir" ]; then + # enable globbing to iterate over items + set +f + for dir in "$TMP_DOWNLOAD_DIR"/*; do + if [ -d "$dir" ]; then + if [ -f "$dir/bin/$MVN_CMD" ]; then + actualDistributionDir="$(basename "$dir")" + break + fi + fi + done + set -f +fi + +if [ -z "$actualDistributionDir" ]; then + verbose "Contents of $TMP_DOWNLOAD_DIR:" + verbose "$(ls -la "$TMP_DOWNLOAD_DIR")" + die "Could not find Maven distribution directory in extracted archive" +fi + +verbose "Found extracted Maven distribution directory: $actualDistributionDir" +printf %s\\n "$distributionUrl" >"$TMP_DOWNLOAD_DIR/$actualDistributionDir/mvnw.url" +mv -- "$TMP_DOWNLOAD_DIR/$actualDistributionDir" "$MAVEN_HOME" || [ -d "$MAVEN_HOME" ] || die "fail to move MAVEN_HOME" + +clean || : +exec_maven "$@" diff --git a/java/mvnw.cmd b/java/mvnw.cmd new file mode 100644 index 0000000..92450f9 --- /dev/null +++ b/java/mvnw.cmd @@ -0,0 +1,189 @@ +<# : batch portion +@REM ---------------------------------------------------------------------------- +@REM Licensed to the Apache Software Foundation (ASF) under one +@REM or more contributor license agreements. See the NOTICE file +@REM distributed with this work for additional information +@REM regarding copyright ownership. The ASF licenses this file +@REM to you under the Apache License, Version 2.0 (the +@REM "License"); you may not use this file except in compliance +@REM with the License. You may obtain a copy of the License at +@REM +@REM http://www.apache.org/licenses/LICENSE-2.0 +@REM +@REM Unless required by applicable law or agreed to in writing, +@REM software distributed under the License is distributed on an +@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +@REM KIND, either express or implied. See the License for the +@REM specific language governing permissions and limitations +@REM under the License. +@REM ---------------------------------------------------------------------------- + +@REM ---------------------------------------------------------------------------- +@REM Apache Maven Wrapper startup batch script, version 3.3.4 +@REM +@REM Optional ENV vars +@REM MVNW_REPOURL - repo url base for downloading maven distribution +@REM MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven +@REM MVNW_VERBOSE - true: enable verbose log; others: silence the output +@REM ---------------------------------------------------------------------------- + +@IF "%__MVNW_ARG0_NAME__%"=="" (SET __MVNW_ARG0_NAME__=%~nx0) +@SET __MVNW_CMD__= +@SET __MVNW_ERROR__= +@SET __MVNW_PSMODULEP_SAVE=%PSModulePath% +@SET PSModulePath= +@FOR /F "usebackq tokens=1* delims==" %%A IN (`powershell -noprofile "& {$scriptDir='%~dp0'; $script='%__MVNW_ARG0_NAME__%'; icm -ScriptBlock ([Scriptblock]::Create((Get-Content -Raw '%~f0'))) -NoNewScope}"`) DO @( + IF "%%A"=="MVN_CMD" (set __MVNW_CMD__=%%B) ELSE IF "%%B"=="" (echo %%A) ELSE (echo %%A=%%B) +) +@SET PSModulePath=%__MVNW_PSMODULEP_SAVE% +@SET __MVNW_PSMODULEP_SAVE= +@SET __MVNW_ARG0_NAME__= +@SET MVNW_USERNAME= +@SET MVNW_PASSWORD= +@IF NOT "%__MVNW_CMD__%"=="" ("%__MVNW_CMD__%" %*) +@echo Cannot start maven from wrapper >&2 && exit /b 1 +@GOTO :EOF +: end batch / begin powershell #> + +$ErrorActionPreference = "Stop" +if ($env:MVNW_VERBOSE -eq "true") { + $VerbosePreference = "Continue" +} + +# calculate distributionUrl, requires .mvn/wrapper/maven-wrapper.properties +$distributionUrl = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionUrl +if (!$distributionUrl) { + Write-Error "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties" +} + +switch -wildcard -casesensitive ( $($distributionUrl -replace '^.*/','') ) { + "maven-mvnd-*" { + $USE_MVND = $true + $distributionUrl = $distributionUrl -replace '-bin\.[^.]*$',"-windows-amd64.zip" + $MVN_CMD = "mvnd.cmd" + break + } + default { + $USE_MVND = $false + $MVN_CMD = $script -replace '^mvnw','mvn' + break + } +} + +# apply MVNW_REPOURL and calculate MAVEN_HOME +# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-,maven-mvnd--}/ +if ($env:MVNW_REPOURL) { + $MVNW_REPO_PATTERN = if ($USE_MVND -eq $False) { "/org/apache/maven/" } else { "/maven/mvnd/" } + $distributionUrl = "$env:MVNW_REPOURL$MVNW_REPO_PATTERN$($distributionUrl -replace "^.*$MVNW_REPO_PATTERN",'')" +} +$distributionUrlName = $distributionUrl -replace '^.*/','' +$distributionUrlNameMain = $distributionUrlName -replace '\.[^.]*$','' -replace '-bin$','' + +$MAVEN_M2_PATH = "$HOME/.m2" +if ($env:MAVEN_USER_HOME) { + $MAVEN_M2_PATH = "$env:MAVEN_USER_HOME" +} + +if (-not (Test-Path -Path $MAVEN_M2_PATH)) { + New-Item -Path $MAVEN_M2_PATH -ItemType Directory | Out-Null +} + +$MAVEN_WRAPPER_DISTS = $null +if ((Get-Item $MAVEN_M2_PATH).Target[0] -eq $null) { + $MAVEN_WRAPPER_DISTS = "$MAVEN_M2_PATH/wrapper/dists" +} else { + $MAVEN_WRAPPER_DISTS = (Get-Item $MAVEN_M2_PATH).Target[0] + "/wrapper/dists" +} + +$MAVEN_HOME_PARENT = "$MAVEN_WRAPPER_DISTS/$distributionUrlNameMain" +$MAVEN_HOME_NAME = ([System.Security.Cryptography.SHA256]::Create().ComputeHash([byte[]][char[]]$distributionUrl) | ForEach-Object {$_.ToString("x2")}) -join '' +$MAVEN_HOME = "$MAVEN_HOME_PARENT/$MAVEN_HOME_NAME" + +if (Test-Path -Path "$MAVEN_HOME" -PathType Container) { + Write-Verbose "found existing MAVEN_HOME at $MAVEN_HOME" + Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD" + exit $? +} + +if (! $distributionUrlNameMain -or ($distributionUrlName -eq $distributionUrlNameMain)) { + Write-Error "distributionUrl is not valid, must end with *-bin.zip, but found $distributionUrl" +} + +# prepare tmp dir +$TMP_DOWNLOAD_DIR_HOLDER = New-TemporaryFile +$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir" +$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null +trap { + if ($TMP_DOWNLOAD_DIR.Exists) { + try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null } + catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" } + } +} + +New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null + +# Download and Install Apache Maven +Write-Verbose "Couldn't find MAVEN_HOME, downloading and installing it ..." +Write-Verbose "Downloading from: $distributionUrl" +Write-Verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName" + +$webclient = New-Object System.Net.WebClient +if ($env:MVNW_USERNAME -and $env:MVNW_PASSWORD) { + $webclient.Credentials = New-Object System.Net.NetworkCredential($env:MVNW_USERNAME, $env:MVNW_PASSWORD) +} +[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12 +$webclient.DownloadFile($distributionUrl, "$TMP_DOWNLOAD_DIR/$distributionUrlName") | Out-Null + +# If specified, validate the SHA-256 sum of the Maven distribution zip file +$distributionSha256Sum = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionSha256Sum +if ($distributionSha256Sum) { + if ($USE_MVND) { + Write-Error "Checksum validation is not supported for maven-mvnd. `nPlease disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." + } + Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash + if ((Get-FileHash "$TMP_DOWNLOAD_DIR/$distributionUrlName" -Algorithm SHA256).Hash.ToLower() -ne $distributionSha256Sum) { + Write-Error "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised. If you updated your Maven version, you need to update the specified distributionSha256Sum property." + } +} + +# unzip and move +Expand-Archive "$TMP_DOWNLOAD_DIR/$distributionUrlName" -DestinationPath "$TMP_DOWNLOAD_DIR" | Out-Null + +# Find the actual extracted directory name (handles snapshots where filename != directory name) +$actualDistributionDir = "" + +# First try the expected directory name (for regular distributions) +$expectedPath = Join-Path "$TMP_DOWNLOAD_DIR" "$distributionUrlNameMain" +$expectedMvnPath = Join-Path "$expectedPath" "bin/$MVN_CMD" +if ((Test-Path -Path $expectedPath -PathType Container) -and (Test-Path -Path $expectedMvnPath -PathType Leaf)) { + $actualDistributionDir = $distributionUrlNameMain +} + +# If not found, search for any directory with the Maven executable (for snapshots) +if (!$actualDistributionDir) { + Get-ChildItem -Path "$TMP_DOWNLOAD_DIR" -Directory | ForEach-Object { + $testPath = Join-Path $_.FullName "bin/$MVN_CMD" + if (Test-Path -Path $testPath -PathType Leaf) { + $actualDistributionDir = $_.Name + } + } +} + +if (!$actualDistributionDir) { + Write-Error "Could not find Maven distribution directory in extracted archive" +} + +Write-Verbose "Found extracted Maven distribution directory: $actualDistributionDir" +Rename-Item -Path "$TMP_DOWNLOAD_DIR/$actualDistributionDir" -NewName $MAVEN_HOME_NAME | Out-Null +try { + Move-Item -Path "$TMP_DOWNLOAD_DIR/$MAVEN_HOME_NAME" -Destination $MAVEN_HOME_PARENT | Out-Null +} catch { + if (! (Test-Path -Path "$MAVEN_HOME" -PathType Container)) { + Write-Error "fail to move MAVEN_HOME" + } +} finally { + try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null } + catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" } +} + +Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD" diff --git a/java/pom.xml b/java/pom.xml new file mode 100644 index 0000000..cc4f8da --- /dev/null +++ b/java/pom.xml @@ -0,0 +1,123 @@ + + + + + 4.0.0 + + + org.springframework.boot + spring-boot-starter-parent + 3.3.5 + + + + com.vnp + demo + 0.0.1-SNAPSHOT + mtusi-messenger + + + 21 + 21 + + + + + + + org.springframework.boot + spring-boot-starter-web + + + + + org.springframework.boot + spring-boot-starter-validation + + + + + org.springframework.boot + spring-boot-starter-actuator + + + + + org.springframework.boot + spring-boot-starter-data-jpa + + + + + org.postgresql + postgresql + runtime + + + + org.springframework.boot + spring-boot-starter-data-redis + + + + + org.flywaydb + flyway-core + + + + org.flywaydb + flyway-database-postgresql + + + + + org.springframework.boot + spring-boot-starter-security + + + + + org.springframework.boot + spring-boot-starter-test + test + + + + org.bouncycastle + bcprov-jdk18on + 1.78.1 + + + + + io.rest-assured + rest-assured + test + + + + + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + + org.projectlombok + lombok + + + + + + + + + diff --git a/java/src/main/java/com/vnp/demo/BusinessException.java b/java/src/main/java/com/vnp/demo/BusinessException.java new file mode 100644 index 0000000..d1d4a1f --- /dev/null +++ b/java/src/main/java/com/vnp/demo/BusinessException.java @@ -0,0 +1,63 @@ +package com.vnp.demo; + +import org.springframework.http.HttpStatus; + +public class BusinessException extends RuntimeException { + + private final String code; + private final HttpStatus status; + + public BusinessException(String code, String message, HttpStatus status) { + super(message); + this.code = code; + this.status = status; + } + + public String getCode() { + return code; + } + + public HttpStatus getStatus() { + return status; + } + + public static BusinessException notFound() { + return new BusinessException( + "not_found", + "Объект не найден", + HttpStatus.NOT_FOUND + ); + } + + public static BusinessException conflict() { + return conflict("Конфликт"); + } + + public static BusinessException conflict(String message) { + return new BusinessException( + "conflict", + message, + HttpStatus.CONFLICT + ); + } + + public static BusinessException unauthorized() { + return unauthorized("Пользователь не найден"); + } + + public static BusinessException unauthorized(String message) { + return new BusinessException( + "unauthorized", + message, + HttpStatus.UNAUTHORIZED + ); + } + + public static BusinessException invalid(String message) { + return new BusinessException( + "invalid_request", + message, + HttpStatus.BAD_REQUEST + ); + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/CursorCodec.java b/java/src/main/java/com/vnp/demo/CursorCodec.java new file mode 100644 index 0000000..aa3e1f9 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/CursorCodec.java @@ -0,0 +1,184 @@ +package com.vnp.demo; + +import java.nio.charset.StandardCharsets; +import java.time.Instant; +import java.time.format.DateTimeParseException; +import java.util.Base64; +import java.util.UUID; + +import org.springframework.stereotype.Component; + +@Component +public class CursorCodec { + + public record ChatCursor(Instant createdAt, UUID id) { + } + + public record MessageCursor(Instant createdAt, UUID id) { + } + + public String encodeIndex(int index) { + return Base64.getUrlEncoder() + .withoutPadding() + .encodeToString( + ("i:" + index).getBytes(StandardCharsets.UTF_8) + ); + } + + public int decodeIndex(String cursor, int size) { + try { + String decoded = new String( + Base64.getUrlDecoder().decode(cursor), + StandardCharsets.UTF_8 + ); + + if (!decoded.startsWith("i:")) { + throw new IllegalArgumentException(); + } + + int idx = Integer.parseInt(decoded.substring(2)); + + if (idx < 0 || idx > size) { + throw new IllegalArgumentException(); + } + + return idx; + + } catch (IllegalArgumentException ex) { + throw BusinessException.invalid("Неверный cursor"); + } + } + + public String encodeChat( + UUID userId, + Instant createdAt, + UUID chatId + ) { + String value = "chat:v1:" + + userId + ":" + + createdAt + ":" + + chatId; + + return Base64.getUrlEncoder() + .withoutPadding() + .encodeToString( + value.getBytes(StandardCharsets.UTF_8) + ); + } + + public ChatCursor decodeChat(String cursor, UUID userId) { + try { + String value = decodeBase64(cursor); + + if (!value.startsWith("chat:v1:")) { + throw new IllegalArgumentException(); + } + + String content = value.substring("chat:v1:".length()); + + int firstSeparator = content.indexOf(':'); + int lastSeparator = content.lastIndexOf(':'); + + if (firstSeparator < 0 + || lastSeparator <= firstSeparator) { + throw new IllegalArgumentException(); + } + + UUID cursorUserId = UUID.fromString( + content.substring(0, firstSeparator) + ); + + if (!cursorUserId.equals(userId)) { + throw new IllegalArgumentException(); + } + + Instant createdAt = Instant.parse( + content.substring( + firstSeparator + 1, + lastSeparator + ) + ); + + UUID chatId = UUID.fromString( + content.substring(lastSeparator + 1) + ); + + return new ChatCursor(createdAt, chatId); + + } catch (IllegalArgumentException | DateTimeParseException ex) { + throw BusinessException.invalid("Неверный cursor"); + } + } + + public String encodeMessage( + UUID chatId, + Instant createdAt, + UUID messageId + ) { + String value = "message:v1:" + + chatId + ":" + + createdAt + ":" + + messageId; + + return Base64.getUrlEncoder() + .withoutPadding() + .encodeToString( + value.getBytes(StandardCharsets.UTF_8) + ); + } + + public MessageCursor decodeMessage(String cursor, UUID chatId) { + try { + String value = decodeBase64(cursor); + + if (!value.startsWith("message:v1:")) { + throw new IllegalArgumentException(); + } + + String content = value.substring("message:v1:".length()); + + int firstSeparator = content.indexOf(':'); + int lastSeparator = content.lastIndexOf(':'); + + if (firstSeparator < 0 + || lastSeparator <= firstSeparator) { + throw new IllegalArgumentException(); + } + + UUID cursorChatId = UUID.fromString( + content.substring(0, firstSeparator) + ); + + if (!cursorChatId.equals(chatId)) { + throw new IllegalArgumentException(); + } + + Instant createdAt = Instant.parse( + content.substring( + firstSeparator + 1, + lastSeparator + ) + ); + + UUID messageId = UUID.fromString( + content.substring(lastSeparator + 1) + ); + + return new MessageCursor(createdAt, messageId); + + } catch (IllegalArgumentException | DateTimeParseException ex) { + throw BusinessException.invalid("Неверный cursor"); + } + } + + private String decodeBase64(String cursor) { + if (cursor == null || cursor.isBlank()) { + throw new IllegalArgumentException(); + } + + return new String( + Base64.getUrlDecoder().decode(cursor), + StandardCharsets.UTF_8 + ); + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/GlobalExceptionHandler.java b/java/src/main/java/com/vnp/demo/GlobalExceptionHandler.java new file mode 100644 index 0000000..5e365f3 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/GlobalExceptionHandler.java @@ -0,0 +1,146 @@ + +package com.vnp.demo; + +import org.slf4j.MDC; +import org.springframework.dao.DataAccessException; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.http.converter.HttpMessageNotReadableException; +import org.springframework.web.bind.MethodArgumentNotValidException; +import org.springframework.web.bind.MissingRequestHeaderException; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.RestControllerAdvice; +import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException; +import org.springframework.web.server.ResponseStatusException; +import org.springframework.web.servlet.resource.NoResourceFoundException; + +import com.vnp.demo.dto.ErrorResponse; + +import jakarta.servlet.http.HttpServletRequest; + +@RestControllerAdvice +public class GlobalExceptionHandler { + + private ErrorResponse build(String code, String msg) { + return new ErrorResponse( + new ErrorResponse.ErrorBody( + code, + msg, + MDC.get("requestId") + ) + ); + } + + @ExceptionHandler(BusinessException.class) + public ResponseEntity handleBusiness( + BusinessException e, + HttpServletRequest request + ) { + ResponseEntity.BodyBuilder builder = + ResponseEntity.status(e.getStatus()); + + if (e.getStatus() == HttpStatus.UNAUTHORIZED) { + String path = request.getRequestURI(); + + String challenge = path.equals("/api/v1/auth/sessions") + ? "Basic realm=\"messenger\", charset=\"UTF-8\"" + : "Bearer realm=\"messenger\""; + + builder.header("WWW-Authenticate", challenge); + } + + return builder.body( + build(e.getCode(), e.getMessage()) + ); + } + + @ExceptionHandler(MethodArgumentNotValidException.class) + public ResponseEntity handleValidation( + MethodArgumentNotValidException e + ) { + String msg = e.getBindingResult() + .getFieldErrors() + .stream() + .findFirst() + .map(f -> f.getField() + ": " + f.getDefaultMessage()) + .orElse("Ошибка валидации"); + + return ResponseEntity.badRequest() + .body(build("invalid_request", msg)); + } + + @ExceptionHandler({ + HttpMessageNotReadableException.class, + MethodArgumentTypeMismatchException.class + }) + public ResponseEntity handleMalformed(Exception e) { + return ResponseEntity.badRequest() + .body(build( + "invalid_request", + "Неверный формат запроса" + )); + } + + @ExceptionHandler(NoResourceFoundException.class) + public ResponseEntity handleNotFound( + NoResourceFoundException e + ) { + return ResponseEntity.status(HttpStatus.NOT_FOUND) + .body(build( + "not_found", + "Ресурс не найден" + )); + } + + @ExceptionHandler(MissingRequestHeaderException.class) + public ResponseEntity handleMissingHeader( + MissingRequestHeaderException e + ) { + return ResponseEntity.badRequest() + .body(build( + "invalid_request", + "Отсутствует обязательный заголовок: " + + e.getHeaderName() + )); + } + + @ExceptionHandler(DataAccessException.class) + public ResponseEntity handleDataAccess( + DataAccessException e + ) { + return ResponseEntity + .status(HttpStatus.SERVICE_UNAVAILABLE) + .body(build( + "service_unavailable", + "Сервис временно недоступен" + )); + } + + @ExceptionHandler(ResponseStatusException.class) + public ResponseEntity handleStatus( + ResponseStatusException e + ) { + int status = e.getStatusCode().value(); + + String code = status == 503 + ? "service_unavailable" + : "request_failed"; + + String message = status == 503 + ? "Сервис временно недоступен" + : "Запрос не может быть выполнен"; + + return ResponseEntity.status(status) + .body(build(code, message)); + } + + @ExceptionHandler(Exception.class) + public ResponseEntity handleGeneric(Exception e) { + return ResponseEntity + .status(HttpStatus.INTERNAL_SERVER_ERROR) + .body(build( + "internal_error", + "Внутренняя ошибка" + )); + } +} diff --git a/java/src/main/java/com/vnp/demo/MessengerApplication.java b/java/src/main/java/com/vnp/demo/MessengerApplication.java new file mode 100644 index 0000000..482bc6e --- /dev/null +++ b/java/src/main/java/com/vnp/demo/MessengerApplication.java @@ -0,0 +1,13 @@ +package com.vnp.demo; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; + +@SpringBootApplication +public class MessengerApplication { + + public static void main(String[] args) { + SpringApplication.run(MessengerApplication.class, args); + } + +} diff --git a/java/src/main/java/com/vnp/demo/SessionStoreExceptionHandler.java b/java/src/main/java/com/vnp/demo/SessionStoreExceptionHandler.java new file mode 100644 index 0000000..5f98d7b --- /dev/null +++ b/java/src/main/java/com/vnp/demo/SessionStoreExceptionHandler.java @@ -0,0 +1,24 @@ +package com.vnp.demo; + +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.RestControllerAdvice; + +import java.util.Map; + +@RestControllerAdvice +public class SessionStoreExceptionHandler { + + @ExceptionHandler(SessionStoreUnavailableException.class) + public ResponseEntity> handleSessionStoreUnavailable( + SessionStoreUnavailableException ex + ) { + return ResponseEntity + .status(HttpStatus.SERVICE_UNAVAILABLE) + .body(Map.of( + "error", "SERVICE_UNAVAILABLE", + "message", "Session storage is temporarily unavailable" + )); + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/SessionStoreUnavailableException.java b/java/src/main/java/com/vnp/demo/SessionStoreUnavailableException.java new file mode 100644 index 0000000..818fe37 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/SessionStoreUnavailableException.java @@ -0,0 +1,8 @@ +package com.vnp.demo; + +public class SessionStoreUnavailableException extends RuntimeException { + + public SessionStoreUnavailableException(Throwable cause) { + super("Session storage is temporarily unavailable", cause); + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/config/JacksonConfig.java b/java/src/main/java/com/vnp/demo/config/JacksonConfig.java new file mode 100644 index 0000000..1a5e815 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/config/JacksonConfig.java @@ -0,0 +1,22 @@ +package com.vnp.demo.config; + +import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +import com.fasterxml.jackson.databind.cfg.CoercionAction; +import com.fasterxml.jackson.databind.cfg.CoercionInputShape; +import com.fasterxml.jackson.databind.type.LogicalType; + +@Configuration +public class JacksonConfig { + @Bean + public Jackson2ObjectMapperBuilderCustomizer strictTextValues() { + return builder -> builder.postConfigurer(mapper -> + mapper.coercionConfigFor(LogicalType.Textual) + .setCoercion(CoercionInputShape.Integer, CoercionAction.Fail) + .setCoercion(CoercionInputShape.Float, CoercionAction.Fail) + .setCoercion(CoercionInputShape.Boolean, CoercionAction.Fail)); + } +} + diff --git a/java/src/main/java/com/vnp/demo/config/PasswordConfig.java b/java/src/main/java/com/vnp/demo/config/PasswordConfig.java new file mode 100644 index 0000000..7cc12a8 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/config/PasswordConfig.java @@ -0,0 +1,15 @@ +package com.vnp.demo.config; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.security.crypto.argon2.Argon2PasswordEncoder; +import org.springframework.security.crypto.password.PasswordEncoder; + +@Configuration +public class PasswordConfig { + + @Bean + public PasswordEncoder passwordEncoder() { + return Argon2PasswordEncoder.defaultsForSpringSecurity_v5_8(); + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/config/SecurityConfig.java b/java/src/main/java/com/vnp/demo/config/SecurityConfig.java new file mode 100644 index 0000000..4360c6f --- /dev/null +++ b/java/src/main/java/com/vnp/demo/config/SecurityConfig.java @@ -0,0 +1,75 @@ +package com.vnp.demo.config; + +import java.util.Map; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.http.HttpHeaders; +import org.springframework.http.MediaType; +import org.springframework.security.config.annotation.web.builders.HttpSecurity; +import org.springframework.security.config.http.SessionCreationPolicy; +import org.springframework.security.web.SecurityFilterChain; +import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.vnp.demo.filter.BearerAuthenticationFilter; +import com.vnp.demo.service.AuthService; + +import jakarta.servlet.http.HttpServletResponse; + +@Configuration +public class SecurityConfig { + + @Bean + public SecurityFilterChain securityFilterChain( + HttpSecurity http, + AuthService authService, + ObjectMapper objectMapper + ) throws Exception { + + return http + .csrf(csrf -> csrf.disable()) + .httpBasic(basic -> basic.disable()) + .formLogin(form -> form.disable()) + .sessionManagement(session -> session + .sessionCreationPolicy(SessionCreationPolicy.STATELESS) + ) + .authorizeHttpRequests(auth -> auth + .requestMatchers( + "/health/live", + "/health/ready" + ).permitAll() + .requestMatchers( + org.springframework.http.HttpMethod.POST, + "/api/v1/users", + "/api/v1/auth/sessions" + ).permitAll() + .anyRequest().authenticated() + ) + .exceptionHandling(ex -> ex + .authenticationEntryPoint((request, response, exception) -> { + response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); + response.setHeader( + HttpHeaders.WWW_AUTHENTICATE, + "Bearer realm=\"messenger\"" + ); + response.setContentType(MediaType.APPLICATION_JSON_VALUE); + response.setCharacterEncoding("UTF-8"); + + objectMapper.writeValue( + response.getWriter(), + Map.of("error", Map.of( + "code", "unauthorized", + "message", "Требуется авторизация", + "request_id", response.getHeader("X-Request-Id") + )) + ); + }) + ) + .addFilterBefore( + new BearerAuthenticationFilter(authService, objectMapper), + UsernamePasswordAuthenticationFilter.class + ) + .build(); + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/controllers/AuthController.java b/java/src/main/java/com/vnp/demo/controllers/AuthController.java new file mode 100644 index 0000000..1338291 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/controllers/AuthController.java @@ -0,0 +1,93 @@ +package com.vnp.demo.controllers; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.charset.CharacterCodingException; +import java.nio.charset.StandardCharsets; +import java.util.Base64; + +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.annotation.DeleteMapping; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestHeader; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.ResponseStatus; +import org.springframework.web.bind.annotation.RestController; + +import com.vnp.demo.BusinessException; +import com.vnp.demo.dto.SessionResponse; +import com.vnp.demo.service.AuthService; + +import jakarta.servlet.http.HttpServletRequest; + +@RestController +@RequestMapping("/api/v1/auth/sessions") +public class AuthController { + + private final AuthService authService; + + public AuthController(AuthService authService) { + this.authService = authService; + } + + @PostMapping + @ResponseStatus(HttpStatus.CREATED) + public SessionResponse login( + @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) + String authorization, + HttpServletRequest request + ) throws IOException { + if (request.getInputStream().read() != -1) { + throw BusinessException.invalid("Тело запроса создания сессии должно быть пустым"); + } + if (authorization == null + || !authorization.startsWith("Basic ")) { + throw BusinessException.unauthorized(); + } + + String encoded = authorization.substring(6).trim(); + String credentials; + + try { + byte[] decoded = Base64.getDecoder().decode(encoded); + + credentials = StandardCharsets.UTF_8 + .newDecoder() + .decode(ByteBuffer.wrap(decoded)) + .toString(); + + } catch (IllegalArgumentException | CharacterCodingException ex) { + throw BusinessException.unauthorized(); + } + + int separator = credentials.indexOf(':'); + + if (separator < 0) { + throw BusinessException.unauthorized(); + } + + String username = credentials.substring(0, separator); + String password = credentials.substring(separator + 1); + + if (!username.matches("[a-z0-9_]{3,32}")) { + throw BusinessException.unauthorized(); + } + + return authService.login(username, password); + } + + @DeleteMapping("/current") + @ResponseStatus(HttpStatus.NO_CONTENT) + public void logout( + @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) + String authorization + ) { + if (authorization == null + || !authorization.startsWith("Bearer ")) { + throw BusinessException.unauthorized(); + } + + authService.logout(authorization.substring(7).trim()); + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/controllers/ChatController.java b/java/src/main/java/com/vnp/demo/controllers/ChatController.java new file mode 100644 index 0000000..7e3baa4 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/controllers/ChatController.java @@ -0,0 +1,58 @@ +package com.vnp.demo.controllers; + +import java.util.UUID; + +import org.springframework.http.HttpStatus; +import org.springframework.security.core.annotation.AuthenticationPrincipal; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.ResponseStatus; +import org.springframework.web.bind.annotation.RestController; + +import com.vnp.demo.dto.ChatCreateRequest; +import com.vnp.demo.dto.ChatPageResponse; +import com.vnp.demo.dto.ChatResponse; +import com.vnp.demo.service.ChatService; + +import jakarta.validation.Valid; + +@RestController +@RequestMapping("/api/v1/chats") +public class ChatController { + + private final ChatService chatService; + + public ChatController(ChatService chatService) { + this.chatService = chatService; + } + + @PostMapping + @ResponseStatus(HttpStatus.CREATED) + public ChatResponse create( + @AuthenticationPrincipal UUID userId, + @Valid @RequestBody ChatCreateRequest request + ) { + return chatService.create(userId, request); + } + + @GetMapping + public ChatPageResponse list( + @AuthenticationPrincipal UUID userId, + @RequestParam(defaultValue = "50") int limit, + @RequestParam(required = false) String cursor + ) { + return chatService.list(userId, limit, cursor); + } + + @GetMapping("/{chat_id}") + public ChatResponse get( + @AuthenticationPrincipal UUID userId, + @PathVariable("chat_id") UUID chatId + ) { + return chatService.get(userId, chatId); + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/controllers/HealthController.java b/java/src/main/java/com/vnp/demo/controllers/HealthController.java new file mode 100644 index 0000000..21aa759 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/controllers/HealthController.java @@ -0,0 +1,38 @@ +package com.vnp.demo.controllers; + +import org.springframework.boot.availability.ApplicationAvailability; +import org.springframework.boot.availability.ReadinessState; +import org.springframework.data.redis.core.StringRedisTemplate; +import org.springframework.http.HttpStatus; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import com.vnp.demo.BusinessException; +import com.vnp.demo.dto.HealthResponse; + +@RestController +@RequestMapping("/health") +public class HealthController { + private final JdbcTemplate jdbc; + private final StringRedisTemplate redis; + private final ApplicationAvailability availability; + public HealthController(JdbcTemplate jdbc, StringRedisTemplate redis, ApplicationAvailability availability) { + this.jdbc = jdbc; this.redis = redis; this.availability = availability; + } + @GetMapping("/live") + public HealthResponse live() { return HealthResponse.ok(); } + @GetMapping("/ready") + public HealthResponse ready() { + try { + if (availability.getReadinessState() != ReadinessState.ACCEPTING_TRAFFIC) throw new IllegalStateException(); + if (!Integer.valueOf(1).equals(jdbc.queryForObject("SELECT 1", Integer.class))) throw new IllegalStateException(); + String pong = redis.execute((org.springframework.data.redis.core.RedisCallback) c -> c.ping()); + if (!"PONG".equals(pong)) throw new IllegalStateException(); + return HealthResponse.ok(); + } catch (Exception ex) { + throw new BusinessException("unavailable", "Сервис не готов", HttpStatus.SERVICE_UNAVAILABLE); + } + } +} diff --git a/java/src/main/java/com/vnp/demo/controllers/MessageController.java b/java/src/main/java/com/vnp/demo/controllers/MessageController.java new file mode 100644 index 0000000..f048f81 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/controllers/MessageController.java @@ -0,0 +1,53 @@ +package com.vnp.demo.controllers; + +import java.util.UUID; + +import org.springframework.http.HttpStatus; +import org.springframework.security.core.annotation.AuthenticationPrincipal; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.ResponseStatus; +import org.springframework.web.bind.annotation.RestController; + +import com.vnp.demo.dto.MessageCreateRequest; +import com.vnp.demo.dto.MessagePageResponse; +import com.vnp.demo.dto.MessageResponse; +import com.vnp.demo.service.MessageService; + +import jakarta.validation.Valid; + +@RestController +@RequestMapping("/api/v1/chats/{chat_id}/messages") +public class MessageController { + + private final MessageService messageService; + + public MessageController(MessageService messageService) { + this.messageService = messageService; + } + + @PostMapping + @ResponseStatus(HttpStatus.CREATED) + public MessageResponse create( + @AuthenticationPrincipal UUID userId, + @PathVariable("chat_id") UUID chatId, + @org.springframework.web.bind.annotation.RequestHeader("Idempotency-Key") String key, + @Valid @RequestBody MessageCreateRequest request + ) { + return messageService.create(userId, chatId, request, key); + } + + @GetMapping + public MessagePageResponse list( + @AuthenticationPrincipal UUID userId, + @PathVariable("chat_id") UUID chatId, + @RequestParam(defaultValue = "50") int limit, + @RequestParam(required = false) String cursor + ) { + return messageService.list(userId, chatId, limit, cursor); + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/controllers/UserController.java b/java/src/main/java/com/vnp/demo/controllers/UserController.java new file mode 100644 index 0000000..3640073 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/controllers/UserController.java @@ -0,0 +1,44 @@ +package com.vnp.demo.controllers; + +import java.util.UUID; + +import org.springframework.http.HttpStatus; +import org.springframework.security.core.annotation.AuthenticationPrincipal; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.ResponseStatus; +import org.springframework.web.bind.annotation.RestController; + +import com.vnp.demo.dto.UserCreateRequest; +import com.vnp.demo.dto.UserResponse; +import com.vnp.demo.service.UserService; + +import jakarta.validation.Valid; + +@RestController +@RequestMapping("/api/v1/users") +public class UserController { + + private final UserService userService; + + public UserController(UserService userService) { + this.userService = userService; + } + + @PostMapping + @ResponseStatus(HttpStatus.CREATED) + public UserResponse register( + @Valid @RequestBody UserCreateRequest request + ) { + return userService.register(request); + } + + @GetMapping("/me") + public UserResponse getCurrent( + @AuthenticationPrincipal UUID userId + ) { + return userService.getCurrent(userId); + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/dto/ChatCreateRequest.java b/java/src/main/java/com/vnp/demo/dto/ChatCreateRequest.java new file mode 100644 index 0000000..12ecd68 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/dto/ChatCreateRequest.java @@ -0,0 +1,23 @@ +package com.vnp.demo.dto; + +import com.fasterxml.jackson.annotation.JsonProperty; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotEmpty; +import jakarta.validation.constraints.NotNull; +import jakarta.validation.constraints.Size; +import org.hibernate.validator.constraints.UniqueElements; + +import java.util.List; +import java.util.UUID; + +public record ChatCreateRequest( + @NotBlank + @Size(max = 100) + String title, + + @NotEmpty + @Size(max = 100) + @UniqueElements + @JsonProperty("member_ids") + List<@NotNull UUID> memberIds +) {} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/dto/ChatPageResponse.java b/java/src/main/java/com/vnp/demo/dto/ChatPageResponse.java new file mode 100644 index 0000000..6c5fbd8 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/dto/ChatPageResponse.java @@ -0,0 +1,10 @@ +package com.vnp.demo.dto; + +import java.util.List; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public record ChatPageResponse( + List items, + @JsonProperty("next_cursor") String nextCursor +) {} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/dto/ChatResponse.java b/java/src/main/java/com/vnp/demo/dto/ChatResponse.java new file mode 100644 index 0000000..f29a6ed --- /dev/null +++ b/java/src/main/java/com/vnp/demo/dto/ChatResponse.java @@ -0,0 +1,16 @@ +package com.vnp.demo.dto; + +import com.fasterxml.jackson.annotation.JsonProperty; + +import java.time.Instant; +import java.util.List; +import java.util.UUID; + +public record ChatResponse( + UUID id, + String title, + @JsonProperty("member_ids") + List memberIds, + @JsonProperty("created_at") + Instant createdAt +) {} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/dto/ErrorResponse.java b/java/src/main/java/com/vnp/demo/dto/ErrorResponse.java new file mode 100644 index 0000000..e2aef6a --- /dev/null +++ b/java/src/main/java/com/vnp/demo/dto/ErrorResponse.java @@ -0,0 +1,14 @@ +package com.vnp.demo.dto; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public record ErrorResponse(ErrorBody error) { + public record ErrorBody( + String code, + + String message, + + @JsonProperty("request_id") + String requestId + ) {} + } \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/dto/HealthResponse.java b/java/src/main/java/com/vnp/demo/dto/HealthResponse.java new file mode 100644 index 0000000..7d6b2f8 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/dto/HealthResponse.java @@ -0,0 +1,6 @@ +package com.vnp.demo.dto; + +public record HealthResponse(String status) { + public static HealthResponse ok() + { return new HealthResponse("ok"); } +} diff --git a/java/src/main/java/com/vnp/demo/dto/MessageCreateRequest.java b/java/src/main/java/com/vnp/demo/dto/MessageCreateRequest.java new file mode 100644 index 0000000..d0485e2 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/dto/MessageCreateRequest.java @@ -0,0 +1,8 @@ +package com.vnp.demo.dto; + +import jakarta.validation.constraints.NotBlank; + +public record MessageCreateRequest( + @NotBlank String text +) { +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/dto/MessagePageResponse.java b/java/src/main/java/com/vnp/demo/dto/MessagePageResponse.java new file mode 100644 index 0000000..2f5cdf1 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/dto/MessagePageResponse.java @@ -0,0 +1,10 @@ +package com.vnp.demo.dto; + +import java.util.List; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public record MessagePageResponse( + List items, + @JsonProperty("next_cursor") String nextCursor +) {} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/dto/MessageResponse.java b/java/src/main/java/com/vnp/demo/dto/MessageResponse.java new file mode 100644 index 0000000..40aeee8 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/dto/MessageResponse.java @@ -0,0 +1,21 @@ +package com.vnp.demo.dto; + +import java.time.Instant; +import java.util.UUID; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public record MessageResponse( + UUID id, + + @JsonProperty("chat_id") + UUID chat_id, + + @JsonProperty("sender_id") + UUID sender_id, + + String text, + + @JsonProperty("created_at") + Instant createdAt +){} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/dto/SessionResponse.java b/java/src/main/java/com/vnp/demo/dto/SessionResponse.java new file mode 100644 index 0000000..fb84718 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/dto/SessionResponse.java @@ -0,0 +1,13 @@ +package com.vnp.demo.dto; + +import java.time.Instant; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public record SessionResponse( + String token, + @JsonProperty("token_type") String tokenType, + @JsonProperty("expires_at") Instant expiresAt, + UserResponse user +) { +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/dto/UserCreateRequest.java b/java/src/main/java/com/vnp/demo/dto/UserCreateRequest.java new file mode 100644 index 0000000..14cbc8a --- /dev/null +++ b/java/src/main/java/com/vnp/demo/dto/UserCreateRequest.java @@ -0,0 +1,18 @@ +package com.vnp.demo.dto; + +import com.fasterxml.jackson.annotation.JsonProperty; +import jakarta.validation.constraints.*; + +public record UserCreateRequest( + + @NotBlank + @Pattern(regexp = "^[a-z0-9_]{3,32}$") + String username, + + @JsonProperty("display_name") + @NotBlank + String displayName, + + @NotNull + String password +) {} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/dto/UserResponse.java b/java/src/main/java/com/vnp/demo/dto/UserResponse.java new file mode 100644 index 0000000..4e5c008 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/dto/UserResponse.java @@ -0,0 +1,21 @@ +package com.vnp.demo.dto; + +import java.time.Instant; +import java.util.UUID; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public record UserResponse( + + UUID id, + + String username, + + @JsonProperty("display_name") + String displayName, + + @JsonProperty("created_at") + Instant createdAt + +) { +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/filter/BearerAuthenticationFilter.java b/java/src/main/java/com/vnp/demo/filter/BearerAuthenticationFilter.java new file mode 100644 index 0000000..e751149 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/filter/BearerAuthenticationFilter.java @@ -0,0 +1,148 @@ + +package com.vnp.demo.filter; + +import java.io.IOException; +import java.util.List; +import java.util.Map; + +import org.springframework.dao.DataAccessException; +import org.springframework.http.HttpHeaders; +import org.springframework.http.MediaType; +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; +import org.springframework.security.core.context.SecurityContextHolder; +import org.springframework.transaction.CannotCreateTransactionException; +import org.springframework.web.filter.OncePerRequestFilter; +import org.springframework.web.server.ResponseStatusException; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.vnp.demo.BusinessException; +import com.vnp.demo.SessionStoreUnavailableException; +import com.vnp.demo.models.User; +import com.vnp.demo.service.AuthService; + +import jakarta.servlet.FilterChain; +import jakarta.servlet.ServletException; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; + +public class BearerAuthenticationFilter extends OncePerRequestFilter { + + private final AuthService authService; + private final ObjectMapper objectMapper; + + public BearerAuthenticationFilter( + AuthService authService, + ObjectMapper objectMapper + ) { + this.authService = authService; + this.objectMapper = objectMapper; + } + + @Override + protected void doFilterInternal( + HttpServletRequest request, + HttpServletResponse response, + FilterChain chain + ) throws ServletException, IOException { + + String authorization = request.getHeader(HttpHeaders.AUTHORIZATION); + + if (authorization == null || !authorization.startsWith("Bearer ")) { + chain.doFilter(request, response); + return; + } + + String token = authorization.substring(7).trim(); + + User user; + + try { + user = authService.authenticate(token); + + } catch (BusinessException ex) { + SecurityContextHolder.clearContext(); + + response.setHeader( + HttpHeaders.WWW_AUTHENTICATE, + "Bearer realm=\"messenger\"" + ); + + writeError( + response, + HttpServletResponse.SC_UNAUTHORIZED, + "unauthorized", + "Недействительный токен" + ); + return; + + } catch (SessionStoreUnavailableException | DataAccessException | CannotCreateTransactionException ex) { + SecurityContextHolder.clearContext(); + + writeError( + response, + HttpServletResponse.SC_SERVICE_UNAVAILABLE, + "unavailable", + "Сервис временно недоступен" + ); + return; + + } catch (ResponseStatusException ex) { + SecurityContextHolder.clearContext(); + + if (ex.getStatusCode().value() == 503) { + writeError( + response, + HttpServletResponse.SC_SERVICE_UNAVAILABLE, + "unavailable", + "Сервис временно недоступен" + ); + return; + } + + throw ex; + } + + try { + UsernamePasswordAuthenticationToken authentication = + new UsernamePasswordAuthenticationToken( + user.getId(), + null, + List.of() + ); + + SecurityContextHolder.getContext() + .setAuthentication(authentication); + + chain.doFilter(request, response); + + } finally { + SecurityContextHolder.clearContext(); + } + } + + private void writeError( + HttpServletResponse response, + int status, + String code, + String message + ) throws IOException { + + response.setStatus(status); + response.setContentType(MediaType.APPLICATION_JSON_VALUE); + response.setCharacterEncoding("UTF-8"); + + String requestId = response.getHeader("X-Request-Id"); + + objectMapper.writeValue( + response.getWriter(), + Map.of( + "error", Map.of( + "code", code, + "message", message, + "request_id", + requestId != null ? requestId : "" + ) + ) + ); + } +} diff --git a/java/src/main/java/com/vnp/demo/filter/RequestIdFilter.java b/java/src/main/java/com/vnp/demo/filter/RequestIdFilter.java new file mode 100644 index 0000000..94b7e9f --- /dev/null +++ b/java/src/main/java/com/vnp/demo/filter/RequestIdFilter.java @@ -0,0 +1,77 @@ +package com.vnp.demo.filter; + +import java.io.IOException; +import java.util.UUID; + +import org.slf4j.MDC; +import org.springframework.core.Ordered; +import org.springframework.core.annotation.Order; +import org.springframework.stereotype.Component; +import org.springframework.web.filter.OncePerRequestFilter; + +import jakarta.servlet.FilterChain; +import jakarta.servlet.ServletException; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; + +@Component +@Order(Ordered.HIGHEST_PRECEDENCE) +public class RequestIdFilter extends OncePerRequestFilter { + + private final String instanceId = System.getenv().getOrDefault("HOSTNAME", UUID.randomUUID().toString()); + + public static final String HEADER = "X-Request-Id"; + public static final String MDC_KEY = "requestId"; + + private static final int MAX_REQUEST_ID_LENGTH = 128; + + @Override + protected void doFilterInternal( + HttpServletRequest request, + HttpServletResponse response, + FilterChain chain + ) throws ServletException, IOException { + + String requestId = request.getHeader(HEADER); + + if (requestId == null + || requestId.isBlank() + || requestId.length() > MAX_REQUEST_ID_LENGTH + || !isValidRequestId(requestId)) { + + requestId = UUID.randomUUID() + .toString() + .replace("-", ""); + } + + response.setHeader(HEADER, requestId); + response.setHeader("X-Instance-Id", instanceId); + request.setAttribute(MDC_KEY, requestId); + + MDC.put(MDC_KEY, requestId); + + try { + chain.doFilter(request, response); + } finally { + MDC.remove(MDC_KEY); + } + } + + private boolean isValidRequestId(String requestId) { + for (int i = 0; i < requestId.length(); i++) { + char c = requestId.charAt(i); + + if (!( + (c >= 'a' && c <= 'z') + || (c >= 'A' && c <= 'Z') + || (c >= '0' && c <= '9') + || c == '-' + || c == '_' + )) { + return false; + } + } + + return true; + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/models/Chat.java b/java/src/main/java/com/vnp/demo/models/Chat.java new file mode 100644 index 0000000..64b9839 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/models/Chat.java @@ -0,0 +1,46 @@ +package com.vnp.demo.models; + +import java.time.Instant; +import java.util.UUID; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.Id; +import jakarta.persistence.Table; + +@Entity +@Table(name = "chats") +public class Chat { + + @Id + private UUID id = UUID.randomUUID(); + + @Column(nullable = false, length = 400) + private String title; + + @Column(name = "created_at", nullable = false) + private Instant createdAt = Instant.now(); + + protected Chat() { + } + + public Chat(String title) { + this.title = title; + } + + public UUID getId() { + return id; + } + + public String getTitle() { + return title; + } + + public Instant getCreatedAt() { + return createdAt; + } + + public void setTitle(String title) { + this.title = title; + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/models/ChatMember.java b/java/src/main/java/com/vnp/demo/models/ChatMember.java new file mode 100644 index 0000000..9ab0382 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/models/ChatMember.java @@ -0,0 +1,45 @@ +package com.vnp.demo.models; + +import jakarta.persistence.*; + +@Entity +@Table(name = "chat_members") +public class ChatMember { + + @EmbeddedId + private ChatMemberId id; + + @MapsId("chatId") + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @JoinColumn(name = "chat_id", nullable = false) + private Chat chat; + + @MapsId("userId") + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @JoinColumn(name = "user_id", nullable = false) + private User user; + + protected ChatMember() { + } + + public ChatMember(Chat chat, User user) { + this.chat = chat; + this.user = user; + this.id = new ChatMemberId( + chat.getId(), + user.getId() + ); + } + + public ChatMemberId getId() { + return id; + } + + public Chat getChat() { + return chat; + } + + public User getUser() { + return user; + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/models/ChatMemberId.java b/java/src/main/java/com/vnp/demo/models/ChatMemberId.java new file mode 100644 index 0000000..01af009 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/models/ChatMemberId.java @@ -0,0 +1,53 @@ +package com.vnp.demo.models; + +import java.io.Serializable; +import java.util.Objects; +import java.util.UUID; + +import jakarta.persistence.Column; +import jakarta.persistence.Embeddable; + +@Embeddable +public class ChatMemberId implements Serializable { + + @Column(name = "chat_id", nullable = false) + private UUID chatId; + + @Column(name = "user_id", nullable = false) + private UUID userId; + + protected ChatMemberId() { + } + + public ChatMemberId(UUID chatId, UUID userId) { + this.chatId = chatId; + this.userId = userId; + } + + public UUID getChatId() { + return chatId; + } + + public UUID getUserId() { + return userId; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + + if (!(obj instanceof ChatMemberId other)) { + return false; + } + + return Objects.equals(chatId, other.chatId) + && Objects.equals(userId, other.userId); + } + + @Override + public int hashCode() { + return Objects.hash(chatId, userId); + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/models/Message.java b/java/src/main/java/com/vnp/demo/models/Message.java new file mode 100644 index 0000000..8a3a5d0 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/models/Message.java @@ -0,0 +1,63 @@ +package com.vnp.demo.models; + +import java.time.Instant; +import java.util.UUID; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.FetchType; +import jakarta.persistence.Id; +import jakarta.persistence.JoinColumn; +import jakarta.persistence.ManyToOne; +import jakarta.persistence.Table; + +@Entity +@Table(name = "messages") +public class Message { + + @Id + private UUID id = UUID.randomUUID(); + + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @JoinColumn(name = "chat_id", nullable = false) + private Chat chat; + + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @JoinColumn(name = "sender_id", nullable = false) + private User sender; + + @Column(name = "text", nullable = false, columnDefinition = "text") + private String text; + + @Column(name = "created_at", nullable = false) + private Instant createdAt = Instant.now(); + + protected Message() { + } + + public Message(Chat chat, User sender, String text) { + this.chat = chat; + this.sender = sender; + this.text = text; + } + + public UUID getId() { + return id; + } + + public Chat getChat() { + return chat; + } + + public User getSender() { + return sender; + } + + public String getText() { + return text; + } + + public Instant getCreatedAt() { + return createdAt; + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/models/Session.java b/java/src/main/java/com/vnp/demo/models/Session.java new file mode 100644 index 0000000..cdbf6d9 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/models/Session.java @@ -0,0 +1,90 @@ +package com.vnp.demo.models; + +import java.sql.Types; +import java.time.Instant; +import java.util.UUID; + +import org.hibernate.annotations.JdbcTypeCode; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.FetchType; +import jakarta.persistence.Id; +import jakarta.persistence.JoinColumn; +import jakarta.persistence.ManyToOne; +import jakarta.persistence.Table; + +@Entity +@Table(name = "sessions") +public class Session { + + @Id + private UUID id = UUID.randomUUID(); + + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @JoinColumn(name = "user_id", nullable = false) + private User user; + + @JdbcTypeCode(Types.CHAR) + @Column( + name = "token_hash", + nullable = false, + unique = true, + length = 64, + columnDefinition = "CHAR(64)" + ) + private String tokenHash; + + @Column(name = "expires_at", nullable = false) + private Instant expiresAt; + + @Column(name = "revoked_at") + private Instant revokedAt; + + @Column(name = "created_at", nullable = false) + private Instant createdAt = Instant.now(); + + protected Session() { + } + + public Session(User user, String tokenHash, Instant expiresAt) { + this.user = user; + this.tokenHash = tokenHash; + this.expiresAt = expiresAt; + } + + public UUID getId() { + return id; + } + + public User getUser() { + return user; + } + + public String getTokenHash() { + return tokenHash; + } + + public Instant getExpiresAt() { + return expiresAt; + } + + public Instant getRevokedAt() { + return revokedAt; + } + + public Instant getCreatedAt() { + return createdAt; + } + + public boolean isValid() { + return revokedAt == null + && expiresAt.isAfter(Instant.now()); + } + + public void revoke() { + if (revokedAt == null) { + revokedAt = Instant.now(); + } + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/models/User.java b/java/src/main/java/com/vnp/demo/models/User.java new file mode 100644 index 0000000..f9af630 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/models/User.java @@ -0,0 +1,63 @@ +package com.vnp.demo.models; + +import java.time.Instant; +import java.time.temporal.ChronoUnit; +import java.util.UUID; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.Id; +import jakarta.persistence.Table; + +@Entity +@Table(name = "users") +public class User { + + @Id + private UUID id = UUID.randomUUID(); + + @Column(nullable = false, unique = true, length = 32) + private String username; + + @Column(name = "display_name", nullable = false) + private String displayName; + + @Column(name = "password_hash", nullable = false) + private String passwordHash; + + @Column(name = "created_at", nullable = false) + private Instant createdAt = Instant.now().truncatedTo(ChronoUnit.MICROS); + + protected User() { + } + + public User(String username, String displayName, String passwordHash) { + this.username = username; + this.displayName = displayName; + this.passwordHash = passwordHash; + } + + public UUID getId() { + return id; + } + + public String getUsername() { + return username; + } + + public String getDisplayName() { + return displayName; + } + + public String getPasswordHash() { + return passwordHash; + } + + public Instant getCreatedAt() { + return createdAt; + } + + public void setDisplayName(String displayName) { + this.displayName = displayName; + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/repositories/ChatMemberRepository.java b/java/src/main/java/com/vnp/demo/repositories/ChatMemberRepository.java new file mode 100644 index 0000000..7b68cab --- /dev/null +++ b/java/src/main/java/com/vnp/demo/repositories/ChatMemberRepository.java @@ -0,0 +1,19 @@ +package com.vnp.demo.repositories; + +import java.util.List; +import java.util.UUID; + +import org.springframework.data.jpa.repository.JpaRepository; + +import com.vnp.demo.models.ChatMember; +import com.vnp.demo.models.ChatMemberId; + +public interface ChatMemberRepository + extends JpaRepository { + + boolean existsByIdChatIdAndIdUserId(UUID chatId, UUID userId); + + List findByIdChatId(UUID chatId); + + boolean existsByChat_IdAndUser_Id(UUID chatId, UUID userId); +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/repositories/ChatRepository.java b/java/src/main/java/com/vnp/demo/repositories/ChatRepository.java new file mode 100644 index 0000000..320e00e --- /dev/null +++ b/java/src/main/java/com/vnp/demo/repositories/ChatRepository.java @@ -0,0 +1,56 @@ +package com.vnp.demo.repositories; + +import java.time.Instant; +import java.util.List; +import java.util.UUID; + +import org.springframework.data.domain.Pageable; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; + +import com.vnp.demo.models.Chat; + +public interface ChatRepository extends JpaRepository { + + @Query(""" + SELECT c + FROM Chat c + WHERE EXISTS ( + SELECT 1 + FROM ChatMember cm + WHERE cm.chat.id = c.id + AND cm.user.id = :userId + ) + ORDER BY c.createdAt ASC, c.id ASC + """) + List findFirstPage( + @Param("userId") UUID userId, + Pageable pageable + ); + + @Query(""" + SELECT c + FROM Chat c + WHERE EXISTS ( + SELECT 1 + FROM ChatMember cm + WHERE cm.chat.id = c.id + AND cm.user.id = :userId + ) + AND ( + c.createdAt > :cursorTime + OR ( + c.createdAt = :cursorTime + AND c.id > :cursorId + ) + ) + ORDER BY c.createdAt ASC, c.id ASC + """) + List findNextPage( + @Param("userId") UUID userId, + @Param("cursorTime") Instant cursorTime, + @Param("cursorId") UUID cursorId, + Pageable pageable + ); +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/repositories/MessageRepository.java b/java/src/main/java/com/vnp/demo/repositories/MessageRepository.java new file mode 100644 index 0000000..c726cb6 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/repositories/MessageRepository.java @@ -0,0 +1,40 @@ +package com.vnp.demo.repositories; + +import java.time.Instant; +import java.util.List; +import java.util.UUID; + +import org.springframework.data.domain.Pageable; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; + +import com.vnp.demo.models.Message; + +public interface MessageRepository extends JpaRepository { + + @Query(value = """ + SELECT m.* + FROM messages m + WHERE m.chat_id = :chatId + ORDER BY m.created_at ASC, m.id ASC + """, nativeQuery = true) + List findFirstPage( + @Param("chatId") UUID chatId, + Pageable pageable + ); + + @Query(value = """ + SELECT m.* + FROM messages m + WHERE m.chat_id = :chatId + AND (m.created_at, m.id) > (:cursorTime, :cursorId) + ORDER BY m.created_at ASC, m.id ASC + """, nativeQuery = true) + List findNextPage( + @Param("chatId") UUID chatId, + @Param("cursorTime") Instant cursorTime, + @Param("cursorId") UUID cursorId, + Pageable pageable + ); +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/repositories/SessionRepository.java b/java/src/main/java/com/vnp/demo/repositories/SessionRepository.java new file mode 100644 index 0000000..db18209 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/repositories/SessionRepository.java @@ -0,0 +1,12 @@ +package com.vnp.demo.repositories; + +import com.vnp.demo.models.Session; +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.Optional; +import java.util.UUID; + +public interface SessionRepository extends JpaRepository { + + Optional findByTokenHash(String tokenHash); +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/repositories/UserRepository.java b/java/src/main/java/com/vnp/demo/repositories/UserRepository.java new file mode 100644 index 0000000..de8c80a --- /dev/null +++ b/java/src/main/java/com/vnp/demo/repositories/UserRepository.java @@ -0,0 +1,14 @@ +package com.vnp.demo.repositories; + +import com.vnp.demo.models.User; +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.Optional; +import java.util.UUID; + +public interface UserRepository extends JpaRepository { + + Optional findByUsername(String username); + + boolean existsByUsername(String username); +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/service/AuthService.java b/java/src/main/java/com/vnp/demo/service/AuthService.java new file mode 100644 index 0000000..3746017 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/service/AuthService.java @@ -0,0 +1,143 @@ +package com.vnp.demo.service; + +import com.vnp.demo.BusinessException; +import com.vnp.demo.dto.SessionResponse; +import com.vnp.demo.dto.UserResponse; +import com.vnp.demo.models.Session; +import com.vnp.demo.models.User; +import com.vnp.demo.repositories.SessionRepository; +import com.vnp.demo.repositories.UserRepository; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.http.HttpStatus; +import org.springframework.security.crypto.password.PasswordEncoder; +import org.springframework.stereotype.Service; +import org.springframework.transaction.PlatformTransactionManager; +import org.springframework.transaction.support.TransactionTemplate; +import org.springframework.web.server.ResponseStatusException; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.security.SecureRandom; +import java.time.Instant; +import java.util.Base64; +import java.util.HexFormat; + +@Service +public class AuthService { + private static final SecureRandom RANDOM = new SecureRandom(); + + private final UserRepository userRepository; + private final SessionRepository sessionRepository; + private final SessionCacheService sessionCacheService; + private final PasswordEncoder passwordEncoder; + private final TransactionTemplate transactions; + private final long sessionTtlSeconds; + + public AuthService( + UserRepository userRepository, + SessionRepository sessionRepository, + SessionCacheService sessionCacheService, + PasswordEncoder passwordEncoder, + PlatformTransactionManager transactionManager, + @Value("${app.session.ttl-seconds:3600}") long sessionTtlSeconds + ) { + if (sessionTtlSeconds <= 0) { + throw new IllegalArgumentException("Session TTL must be positive"); + } + this.userRepository = userRepository; + this.sessionRepository = sessionRepository; + this.sessionCacheService = sessionCacheService; + this.passwordEncoder = passwordEncoder; + this.transactions = new TransactionTemplate(transactionManager); + this.sessionTtlSeconds = sessionTtlSeconds; + } + + public SessionResponse login(String username, String password) { + byte[] bytes = new byte[32]; + RANDOM.nextBytes(bytes); + String token = Base64.getUrlEncoder().withoutPadding().encodeToString(bytes); + String tokenHash = hashToken(token); + Instant expiresAt = Instant.now().plusSeconds(sessionTtlSeconds); + + // TransactionTemplate returns only after the database commit completes. + UserResponse userResponse = transactions.execute(status -> { + User user = userRepository.findByUsername(username) + .orElseThrow(BusinessException::unauthorized); + if (!passwordEncoder.matches(password, user.getPasswordHash())) { + throw BusinessException.unauthorized(); + } + sessionRepository.save(new Session(user, tokenHash, expiresAt)); + return new UserResponse( + user.getId(), user.getUsername(), + user.getDisplayName(), user.getCreatedAt() + ); + }); + + // Never publish a usable token before the PostgreSQL commit. + // If Redis fails, the DB row remains inert: it cannot authenticate. + try { + sessionCacheService.cache(tokenHash, userResponse.id(), expiresAt); + } catch (RuntimeException activationFailure) { + // The token is never returned. Best-effort cleanup handles an + // uncertain Redis write and records the failed activation in PG. + try { + sessionCacheService.invalidate(tokenHash); + } catch (RuntimeException cleanupFailure) { + activationFailure.addSuppressed(cleanupFailure); + } + try { + transactions.executeWithoutResult(status -> + sessionRepository.findByTokenHash(tokenHash) + .ifPresent(Session::revoke) + ); + } catch (RuntimeException cleanupFailure) { + activationFailure.addSuppressed(cleanupFailure); + } + throw activationFailure; + } + return new SessionResponse(token, "Bearer", expiresAt, userResponse); + } + + public User authenticate(String token) { + if (token == null || token.isBlank()) { + throw BusinessException.unauthorized(); + } + var cached = sessionCacheService.find(hashToken(token)) + .orElseThrow(BusinessException::unauthorized); + return userRepository.findById(cached.userId()) + .orElseThrow(BusinessException::unauthorized); + } + + public void logout(String token) { + if (token == null || token.isBlank()) { + throw BusinessException.unauthorized(); + } + String tokenHash = hashToken(token); + if (sessionCacheService.find(tokenHash).isEmpty()) { + throw BusinessException.unauthorized(); + } + + + if (!sessionCacheService.invalidate(tokenHash)) { + throw BusinessException.unauthorized(); + } + + transactions.executeWithoutResult(status -> { + Session session = sessionRepository.findByTokenHash(tokenHash) + .orElseThrow(() -> new ResponseStatusException( + HttpStatus.SERVICE_UNAVAILABLE, "Session record unavailable")); + session.revoke(); + }); + } + + private String hashToken(String token) { + try { + byte[] hash = MessageDigest.getInstance("SHA-256") + .digest(token.getBytes(StandardCharsets.UTF_8)); + return HexFormat.of().formatHex(hash); + } catch (NoSuchAlgorithmException ex) { + throw new IllegalStateException("SHA-256 unavailable", ex); + } + } +} diff --git a/java/src/main/java/com/vnp/demo/service/ChatService.java b/java/src/main/java/com/vnp/demo/service/ChatService.java new file mode 100644 index 0000000..1b4ce67 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/service/ChatService.java @@ -0,0 +1,195 @@ +package com.vnp.demo.service; + +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +import org.springframework.data.domain.PageRequest; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.vnp.demo.BusinessException; +import com.vnp.demo.CursorCodec; +import com.vnp.demo.dto.ChatCreateRequest; +import com.vnp.demo.dto.ChatPageResponse; +import com.vnp.demo.dto.ChatResponse; +import com.vnp.demo.models.Chat; +import com.vnp.demo.models.ChatMember; +import com.vnp.demo.models.User; +import com.vnp.demo.repositories.ChatMemberRepository; +import com.vnp.demo.repositories.ChatRepository; +import com.vnp.demo.repositories.UserRepository; + +@Service +public class ChatService { + + private final ChatRepository chatRepository; + private final ChatMemberRepository chatMemberRepository; + private final UserRepository userRepository; + private final CursorCodec cursorCodec; + + public ChatService( + ChatRepository chatRepository, + ChatMemberRepository chatMemberRepository, + UserRepository userRepository, + CursorCodec cursorCodec + ) { + this.chatRepository = chatRepository; + this.chatMemberRepository = chatMemberRepository; + this.userRepository = userRepository; + this.cursorCodec = cursorCodec; + } + + @Transactional + public ChatResponse create( + UUID currentUserId, + ChatCreateRequest request + ) { + String title = request.title(); + + if (title == null + || title.isBlank() + || title.codePointCount(0, title.length()) > 100) { + throw BusinessException.invalid( + "Некорректное название чата" + ); + } + + List memberIds = request.memberIds(); + + if (memberIds == null + || memberIds.isEmpty() + || !memberIds.contains(currentUserId)) { + throw BusinessException.invalid( + "Создатель должен быть участником чата" + ); + } + + if (memberIds.stream().distinct().count() != memberIds.size()) { + throw BusinessException.invalid( + "Список участников содержит дубликаты" + ); + } + + List users = userRepository.findAllById(memberIds); + + if (users.size() != memberIds.size()) { + throw BusinessException.invalid("Один или несколько участников не найдены"); + } + + // Создаём чат через конструктор существующей модели. + Chat chat = new Chat(title); + chatRepository.save(chat); + + // Создание чата и участников происходит в одной транзакции. + for (User user : users) { + ChatMember member = new ChatMember(chat, user); + chatMemberRepository.save(member); + } + + return toResponse(chat, memberIds); + } + + @Transactional(readOnly = true) + public ChatResponse get( + UUID currentUserId, + UUID chatId + ) { + Chat chat = chatRepository.findById(chatId) + .orElseThrow(BusinessException::notFound); + + if (!chatMemberRepository.existsByIdChatIdAndIdUserId( + chatId, + currentUserId + )) { + throw BusinessException.notFound(); + } + + return toResponse(chat, getMemberIds(chatId)); + } + + @Transactional(readOnly = true) + public ChatPageResponse list( + UUID currentUserId, + Integer limit, + String cursor + ) { + int pageSize = limit == null ? 20 : limit; + + if (pageSize < 1 || pageSize > 100) { + throw BusinessException.invalid( + "limit должен быть от 1 до 100" + ); + } + + List chats; + + if (cursor == null) { + chats = chatRepository.findFirstPage( + currentUserId, + PageRequest.of(0, pageSize + 1) + ); + } else { + CursorCodec.ChatCursor decoded = + cursorCodec.decodeChat(cursor, currentUserId); + + chats = chatRepository.findNextPage( + currentUserId, + decoded.createdAt(), + decoded.id(), + PageRequest.of(0, pageSize + 1) + ); + } + + boolean hasNext = chats.size() > pageSize; + + List page = hasNext + ? chats.subList(0, pageSize) + : chats; + + List items = new ArrayList<>(); + + for (Chat chat : page) { + items.add( + toResponse( + chat, + getMemberIds(chat.getId()) + ) + ); + } + + String nextCursor = null; + + if (hasNext && !page.isEmpty()) { + Chat last = page.get(page.size() - 1); + + nextCursor = cursorCodec.encodeChat( + currentUserId, + last.getCreatedAt(), + last.getId() + ); + } + + return new ChatPageResponse(items, nextCursor); + } + + private List getMemberIds(UUID chatId) { + return chatMemberRepository.findByIdChatId(chatId) + .stream() + .map(member -> member.getId().getUserId()) + .sorted() + .toList(); + } + + private ChatResponse toResponse( + Chat chat, + List memberIds + ) { + return new ChatResponse( + chat.getId(), + chat.getTitle(), + memberIds, + chat.getCreatedAt() + ); + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/service/MessageService.java b/java/src/main/java/com/vnp/demo/service/MessageService.java new file mode 100644 index 0000000..9f61f2f --- /dev/null +++ b/java/src/main/java/com/vnp/demo/service/MessageService.java @@ -0,0 +1,212 @@ +package com.vnp.demo.service; + +import java.util.List; +import java.util.UUID; + +import org.springframework.data.domain.PageRequest; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.vnp.demo.BusinessException; +import com.vnp.demo.CursorCodec; +import com.vnp.demo.dto.MessageCreateRequest; +import com.vnp.demo.dto.MessagePageResponse; +import com.vnp.demo.dto.MessageResponse; +import com.vnp.demo.models.Chat; +import com.vnp.demo.models.Message; +import com.vnp.demo.models.User; +import com.vnp.demo.repositories.ChatMemberRepository; +import com.vnp.demo.repositories.ChatRepository; +import com.vnp.demo.repositories.MessageRepository; +import com.vnp.demo.repositories.UserRepository; + +import jakarta.persistence.EntityManager; +import jakarta.persistence.PersistenceContext; + +@Service +public class MessageService { + + private final MessageRepository messageRepository; + private final ChatRepository chatRepository; + private final ChatMemberRepository chatMemberRepository; + private final UserRepository userRepository; + private final CursorCodec cursorCodec; + + @PersistenceContext + private EntityManager entityManager; + + public MessageService( + MessageRepository messageRepository, + ChatRepository chatRepository, + ChatMemberRepository chatMemberRepository, + UserRepository userRepository, + CursorCodec cursorCodec + ) { + this.messageRepository = messageRepository; + this.chatRepository = chatRepository; + this.chatMemberRepository = chatMemberRepository; + this.userRepository = userRepository; + this.cursorCodec = cursorCodec; + } + + @Transactional + public MessageResponse create( + UUID userId, + UUID chatId, + MessageCreateRequest request, String key + ) { + if (key == null || !key.matches("[A-Za-z0-9._:-]{1,128}")) { + throw BusinessException.invalid("Некорректный Idempotency-Key"); + } + checkAccess(userId, chatId); + + if (request == null + || request.text() == null + || request.text().isBlank() + || request.text().codePointCount( + 0, + request.text().length() + ) > 4000) { + + throw BusinessException.invalid( + "Текст сообщения должен содержать от 1 до 4000 символов" + ); + } + + String scope = userId + ":" + chatId + ":" + key; + entityManager.createNativeQuery("SELECT 1 FROM pg_advisory_xact_lock(hashtextextended(:scope, 0))") + .setParameter("scope", scope).getResultList(); + @SuppressWarnings("unchecked") + List existing = entityManager.createNativeQuery( + "SELECT message_id, request_text FROM message_idempotency " + + "WHERE user_id = :user AND chat_id = :chat AND key = :key") + .setParameter("user", userId).setParameter("chat", chatId) + .setParameter("key", key).getResultList(); + if (!existing.isEmpty()) { + Object[] row = existing.get(0); + if (!request.text().equals(row[1])) { + throw BusinessException.conflict("Ключ уже использован с другим сообщением"); + } + return toResponse(messageRepository.findById((UUID) row[0]).orElseThrow()); + } + + Chat chat = chatRepository.findById(chatId) + .orElseThrow(BusinessException::notFound); + + User sender = userRepository.findById(userId) + .orElseThrow(BusinessException::unauthorized); + + Message message = new Message( + chat, + sender, + request.text() + ); + + Message saved = messageRepository.saveAndFlush(message); + + // Перечитываем значения, фактически сохранённые PostgreSQL. + entityManager.refresh(saved); + + entityManager.createNativeQuery( + "INSERT INTO message_idempotency(user_id, chat_id, key, request_text, message_id) " + + "VALUES (:user, :chat, :key, :text, :message)") + .setParameter("user", userId).setParameter("chat", chatId) + .setParameter("key", key).setParameter("text", request.text()) + .setParameter("message", saved.getId()).executeUpdate(); + return toResponse(saved); + } + + @Transactional(readOnly = true) + public MessagePageResponse list( + UUID userId, + UUID chatId, + int limit, + String cursor + ) { + checkAccess(userId, chatId); + + if (limit < 1 || limit > 100) { + throw BusinessException.invalid( + "limit должен быть от 1 до 100" + ); + } + + CursorCodec.MessageCursor position = null; + + if (cursor != null) { + position = cursorCodec.decodeMessage(cursor, chatId); + } + + List messages; + + if (position == null) { + + messages = messageRepository.findFirstPage( + chatId, + PageRequest.of(0, limit + 1) + ); + + } else { + + messages = messageRepository.findNextPage( + chatId, + position.createdAt(), + position.id(), + PageRequest.of(0, limit + 1) + ); + } + + boolean hasNext = messages.size() > limit; + + List page = hasNext + ? messages.subList(0, limit) + : messages; + + List items = page.stream() + .map(this::toResponse) + .toList(); + + String nextCursor = null; + + if (hasNext && !page.isEmpty()) { + + Message last = page.get(page.size() - 1); + + nextCursor = cursorCodec.encodeMessage( + chatId, + last.getCreatedAt(), + last.getId() + ); + } + + return new MessagePageResponse( + items, + nextCursor + ); + } + + private void checkAccess( + UUID userId, + UUID chatId + ) { + boolean isMember = chatMemberRepository + .existsByIdChatIdAndIdUserId( + chatId, + userId + ); + + if (!isMember) { + throw BusinessException.notFound(); + } + } + + private MessageResponse toResponse(Message message) { + return new MessageResponse( + message.getId(), + message.getChat().getId(), + message.getSender().getId(), + message.getText(), + message.getCreatedAt() + ); + } +} \ No newline at end of file diff --git a/java/src/main/java/com/vnp/demo/service/SessionCacheService.java b/java/src/main/java/com/vnp/demo/service/SessionCacheService.java new file mode 100644 index 0000000..8f10bee --- /dev/null +++ b/java/src/main/java/com/vnp/demo/service/SessionCacheService.java @@ -0,0 +1,72 @@ +package com.vnp.demo.service; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.vnp.demo.SessionStoreUnavailableException; + +import org.springframework.dao.DataAccessException; +import org.springframework.data.redis.core.StringRedisTemplate; +import org.springframework.http.HttpStatus; +import org.springframework.stereotype.Service; +import org.springframework.web.server.ResponseStatusException; + +import java.time.Duration; +import java.time.Instant; +import java.util.Optional; +import java.util.UUID; + +@Service +public class SessionCacheService { + private static final String PREFIX = "session:"; + private final StringRedisTemplate redis; + private final ObjectMapper mapper; + + public SessionCacheService(StringRedisTemplate redis, ObjectMapper mapper) { + this.redis = redis; + this.mapper = mapper; + } + + public record CachedSession(UUID userId, Instant expiresAt) {} + + public Optional find(String tokenHash) { + try { + String json = redis.opsForValue().get(PREFIX + tokenHash); + if (json == null) return Optional.empty(); + CachedSession session = mapper.readValue(json, CachedSession.class); + if (!session.expiresAt().isAfter(Instant.now())) return Optional.empty(); + return Optional.of(session); + } catch (DataAccessException ex) { + throw unavailable(ex); + } catch (JsonProcessingException | IllegalArgumentException ex) { + throw unavailable(ex); + } + } + + public void cache(String tokenHash, UUID userId, Instant expiresAt) { + Duration ttl = Duration.between(Instant.now(), expiresAt); + if (ttl.isNegative() || ttl.isZero()) { + throw new IllegalStateException("Session already expired"); + } + try { + String json = mapper.writeValueAsString(new CachedSession(userId, expiresAt)); + redis.opsForValue().set(PREFIX + tokenHash, json, ttl); + } catch (DataAccessException ex) { + throw unavailable(ex); + } catch (JsonProcessingException ex) { + throw new IllegalStateException("Cannot serialize session", ex); + } + } + + public boolean invalidate(String tokenHash) { + try { + Boolean deleted = redis.delete(PREFIX + tokenHash); + return Boolean.TRUE.equals(deleted); + } catch (DataAccessException ex) { + throw new SessionStoreUnavailableException(ex); + } + } + + private ResponseStatusException unavailable(Exception ex) { + return new ResponseStatusException(HttpStatus.SERVICE_UNAVAILABLE, "Session store unavailable", ex); + } +} diff --git a/java/src/main/java/com/vnp/demo/service/UserService.java b/java/src/main/java/com/vnp/demo/service/UserService.java new file mode 100644 index 0000000..9a1163c --- /dev/null +++ b/java/src/main/java/com/vnp/demo/service/UserService.java @@ -0,0 +1,86 @@ + +package com.vnp.demo.service; + +import java.util.UUID; + +import org.springframework.dao.DataIntegrityViolationException; +import org.springframework.security.crypto.password.PasswordEncoder; +import org.springframework.stereotype.Service; +import org.springframework.transaction.support.TransactionTemplate; + +import com.vnp.demo.BusinessException; +import com.vnp.demo.dto.UserCreateRequest; +import com.vnp.demo.dto.UserResponse; +import com.vnp.demo.models.User; +import com.vnp.demo.repositories.UserRepository; +import com.vnp.demo.validation.UserInputValidator; + +@Service +public class UserService { + + private final UserRepository userRepository; + private final PasswordEncoder passwordEncoder; + private final TransactionTemplate transactionTemplate; + + public UserService( + UserRepository userRepository, + PasswordEncoder passwordEncoder, + TransactionTemplate transactionTemplate + ) { + this.userRepository = userRepository; + this.passwordEncoder = passwordEncoder; + this.transactionTemplate = transactionTemplate; + } + + public UserResponse register(UserCreateRequest request) { + String username = request.username(); + String displayName = request.displayName(); + String password = request.password(); + + UserInputValidator.validate(displayName, password); + + String passwordHash = passwordEncoder.encode(password); + + try { + return transactionTemplate.execute(status -> { + + if (userRepository.existsByUsername(username)) { + throw BusinessException.conflict("Username already exists"); + } + + User user = new User( + username, + displayName, + passwordHash + ); + + User saved = userRepository.saveAndFlush(user); + + return toResponse(saved); + }); + + } catch (DataIntegrityViolationException ex) { + + throw BusinessException.conflict( + "Username already exists" + ); + } + } + + @org.springframework.transaction.annotation.Transactional(readOnly = true) + public UserResponse getCurrent(UUID userId) { + User user = userRepository.findById(userId) + .orElseThrow(BusinessException::notFound); + + return toResponse(user); + } + + public UserResponse toResponse(User user) { + return new UserResponse( + user.getId(), + user.getUsername(), + user.getDisplayName(), + user.getCreatedAt() + ); + } +} diff --git a/java/src/main/java/com/vnp/demo/validation/UserInputValidator.java b/java/src/main/java/com/vnp/demo/validation/UserInputValidator.java new file mode 100644 index 0000000..229cb83 --- /dev/null +++ b/java/src/main/java/com/vnp/demo/validation/UserInputValidator.java @@ -0,0 +1,32 @@ +package com.vnp.demo.validation; + +import com.vnp.demo.BusinessException; + +public final class UserInputValidator { + + private UserInputValidator() { + } + + public static void validate(String displayName, String password) { + + if (displayName == null + || displayName.isBlank() + || codePoints(displayName) > 100) { + throw BusinessException.invalid( + "Некорректное отображаемое имя" + ); + } + + if (password == null + || codePoints(password) < 12 + || codePoints(password) > 128) { + throw BusinessException.invalid( + "Пароль должен содержать от 12 до 128 символов" + ); + } + } + + private static int codePoints(String value) { + return value.codePointCount(0, value.length()); + } +} \ No newline at end of file diff --git a/java/src/main/resources/application.yml b/java/src/main/resources/application.yml new file mode 100644 index 0000000..da6475e --- /dev/null +++ b/java/src/main/resources/application.yml @@ -0,0 +1,49 @@ +server: + shutdown: graceful + tomcat: + threads: + max: 64 + connection-timeout: 2s +spring: + application: + name: messenger + lifecycle: + timeout-per-shutdown-phase: 15s + jackson: + default-property-inclusion: always + deserialization: + fail-on-unknown-properties: true + fail-on-trailing-tokens: true + mapper: + allow-coercion-of-scalars: false + datasource: + url: ${DB_URL:jdbc:postgresql://localhost:5432/messenger} + username: ${DB_USERNAME:messenger} + password: ${DB_PASSWORD:messenger} + hikari: + maximum-pool-size: ${DB_POOL_SIZE:8} + minimum-idle: 1 + connection-timeout: 1000 + validation-timeout: 500 + data-source-properties: + connectTimeout: 2 + socketTimeout: 8 + options: "-c statement_timeout=5000 -c lock_timeout=3000" + data: + redis: + host: ${REDIS_HOST:localhost} + port: 6379 + password: ${REDIS_PASSWORD:} + timeout: 1s + connect-timeout: 1s + flyway: + enabled: ${FLYWAY_ENABLED:true} + jpa: + hibernate: + ddl-auto: validate + open-in-view: false + transaction: + default-timeout: 8s +app: + session: + ttl-seconds: 86400 diff --git a/java/src/main/resources/db/migration/V1__create_tables.sql b/java/src/main/resources/db/migration/V1__create_tables.sql new file mode 100644 index 0000000..4688e46 --- /dev/null +++ b/java/src/main/resources/db/migration/V1__create_tables.sql @@ -0,0 +1,77 @@ + +CREATE TABLE users ( + id UUID PRIMARY KEY, + username VARCHAR(32) NOT NULL UNIQUE, + display_name VARCHAR(400) NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + + CONSTRAINT chk_username + CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT chk_display_name + CHECK ( + char_length(display_name) BETWEEN 1 AND 100 + AND length(btrim(display_name)) > 0 + ) +); + +CREATE TABLE chats ( + id UUID PRIMARY KEY, + title VARCHAR(400) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + + CONSTRAINT chk_chat_title + CHECK ( + char_length(title) BETWEEN 1 AND 100 + AND length(btrim(title)) > 0 + ) +); + +CREATE TABLE chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id), + user_id UUID NOT NULL REFERENCES users(id), + + PRIMARY KEY (chat_id, user_id) +); + +CREATE TABLE messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id), + sender_id UUID NOT NULL, + text VARCHAR(16000) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + + CONSTRAINT fk_message_membership + FOREIGN KEY (chat_id, sender_id) + REFERENCES chat_members(chat_id, user_id), + + CONSTRAINT chk_message_text + CHECK ( + char_length(text) BETWEEN 1 AND 4000 + AND length(btrim(text)) > 0 + ) +); + +CREATE TABLE sessions ( + id UUID PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id), + token_hash CHAR(64) NOT NULL UNIQUE, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + expires_at TIMESTAMPTZ NOT NULL, + revoked_at TIMESTAMPTZ, + + CONSTRAINT chk_session_expiry + CHECK (expires_at > created_at) +); + +CREATE INDEX idx_chat_members_user + ON chat_members(user_id, chat_id); + +CREATE INDEX idx_chats_history + ON chats(created_at, id); + +CREATE INDEX idx_messages_history + ON messages(chat_id, created_at, id); + +CREATE INDEX idx_sessions_user + ON sessions(user_id); diff --git a/java/src/main/resources/db/migration/V2__message_idempotency.sql b/java/src/main/resources/db/migration/V2__message_idempotency.sql new file mode 100644 index 0000000..63cdd87 --- /dev/null +++ b/java/src/main/resources/db/migration/V2__message_idempotency.sql @@ -0,0 +1,9 @@ +CREATE TABLE message_idempotency ( + user_id UUID NOT NULL REFERENCES users(id), + chat_id UUID NOT NULL REFERENCES chats(id), + key VARCHAR(128) COLLATE "C" NOT NULL, + request_text TEXT NOT NULL, + message_id UUID NOT NULL UNIQUE REFERENCES messages(id), + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, chat_id, key) +); diff --git a/java/src/test/java/com/vnp/demo/ConcurrentRegistrationTest.java b/java/src/test/java/com/vnp/demo/ConcurrentRegistrationTest.java new file mode 100644 index 0000000..7468327 --- /dev/null +++ b/java/src/test/java/com/vnp/demo/ConcurrentRegistrationTest.java @@ -0,0 +1,89 @@ +package com.vnp.demo; + +import java.util.UUID; +import java.util.concurrent.Callable; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.web.client.TestRestTemplate; +import org.springframework.http.ResponseEntity; + +import com.vnp.demo.dto.UserCreateRequest; +import com.vnp.demo.repositories.UserRepository; + +@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) +class ConcurrentRegistrationTest { + + @Autowired + private TestRestTemplate restTemplate; + + @Autowired + private UserRepository userRepository; + + @Test + void concurrentRegistrationAllowsOnlyOneUser() throws Exception { + String username = "race_" + + UUID.randomUUID().toString().substring(0, 8); + + UserCreateRequest request = new UserCreateRequest( + username, + "Race Test", + "Password123!" + ); + + ExecutorService executor = Executors.newFixedThreadPool(2); + CountDownLatch start = new CountDownLatch(1); + + try { + Callable> task = () -> { + start.await(); + + return restTemplate.postForEntity( + "/api/v1/users", + request, + String.class + ); + }; + + Future> first = + executor.submit(task); + + Future> second = + executor.submit(task); + + start.countDown(); + + int status1 = first.get(15, TimeUnit.SECONDS) + .getStatusCode().value(); + + int status2 = second.get(15, TimeUnit.SECONDS) + .getStatusCode().value(); + + assertTrue( + (status1 == 201 && status2 == 409) + || (status1 == 409 && status2 == 201), + "Expected 201 and 409, got " + + status1 + " and " + status2 + ); + + assertEquals( + 1, + userRepository.findAll().stream() + .filter(user -> + username.equals(user.getUsername())) + .count() + ); + + } finally { + executor.shutdownNow(); + } + } +} diff --git a/java/src/test/java/com/vnp/demo/InfrastructureFailureIntegrationTest.java b/java/src/test/java/com/vnp/demo/InfrastructureFailureIntegrationTest.java new file mode 100644 index 0000000..f2e64ca --- /dev/null +++ b/java/src/test/java/com/vnp/demo/InfrastructureFailureIntegrationTest.java @@ -0,0 +1,155 @@ + +package com.vnp.demo; + +import java.time.Instant; +import java.util.UUID; + +import static org.hamcrest.Matchers.equalTo; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doThrow; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.mock.mockito.SpyBean; +import org.springframework.boot.test.web.server.LocalServerPort; +import org.springframework.dao.DataAccessResourceFailureException; +import org.springframework.security.crypto.password.PasswordEncoder; + +import com.vnp.demo.models.User; +import com.vnp.demo.repositories.UserRepository; +import com.vnp.demo.service.SessionCacheService; + +import io.restassured.RestAssured; +import static io.restassured.RestAssured.given; + +@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) +class InfrastructureFailureIntegrationTest { + + @LocalServerPort + private int port; + + @SpyBean + private UserRepository userRepository; + + @Autowired + private PasswordEncoder passwordEncoder; + + @SpyBean + private SessionCacheService sessionCacheService; + + private String username; + + private final String password = "Password123!"; + + @BeforeEach + void setUp() { + RestAssured.baseURI = "http://localhost"; + RestAssured.port = port; + + username = "failure_" + UUID.randomUUID() + .toString() + .substring(0, 8); + + User user = new User( + username, + "Failure Test", + passwordEncoder.encode(password) + ); + + userRepository.saveAndFlush(user); + } + + @Test + void redisUnavailableDuringLoginReturns503() { + doThrow(new DataAccessResourceFailureException( + "Redis unavailable" + )).when(sessionCacheService).cache( + anyString(), + any(UUID.class), + any(Instant.class) + ); + + given() + .auth() + .preemptive() + .basic(username, password) + .when() + .post("/api/v1/auth/sessions") + .then() + .statusCode(503) + .body( + "error.code", + equalTo("service_unavailable") + ); + } + + @Test + void anonymousUserCannotBypassAuthentication() { + given() + .header( + "X-User-Id", + UUID.randomUUID().toString() + ) + .when() + .get("/api/v1/users/me") + .then() + .statusCode(401); + } + + @Test + void redisUnavailableDuringAuthenticationDoesNotGrantAccess() { + String token = given() + .auth() + .preemptive() + .basic(username, password) + .when() + .post("/api/v1/auth/sessions") + .then() + .statusCode(201) + .extract() + .path("token"); + + doThrow(new DataAccessResourceFailureException( + "Redis unavailable" + )).when(sessionCacheService).find(anyString()); + + given() + .header( + "Authorization", + "Bearer " + token + ) + .when() + .get("/api/v1/users/me") + .then() + .statusCode(503) + .body( + "error.code", + equalTo("service_unavailable") + ); + } + + @Test + void databaseUnavailableDuringLoginReturns503() { + doThrow(new DataAccessResourceFailureException( + "PostgreSQL unavailable" + )).when(userRepository).findByUsername( + eq(username) + ); + + given() + .auth() + .preemptive() + .basic(username, password) + .when() + .post("/api/v1/auth/sessions") + .then() + .statusCode(503) + .body( + "error.code", + equalTo("service_unavailable") + ); + } +} diff --git a/java/src/test/java/com/vnp/demo/SessionIntegrationTest.java b/java/src/test/java/com/vnp/demo/SessionIntegrationTest.java new file mode 100644 index 0000000..a30b848 --- /dev/null +++ b/java/src/test/java/com/vnp/demo/SessionIntegrationTest.java @@ -0,0 +1,154 @@ + +package com.vnp.demo; + +import java.nio.charset.StandardCharsets; +import java.util.Base64; +import java.util.UUID; + +import static org.hamcrest.Matchers.equalTo; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.web.server.LocalServerPort; +import org.springframework.security.crypto.password.PasswordEncoder; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.vnp.demo.models.User; +import com.vnp.demo.repositories.UserRepository; + +import io.restassured.RestAssured; +import static io.restassured.RestAssured.given; + +@SpringBootTest( + webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, + properties = "app.session.ttl-seconds=2" +) +class SessionIntegrationTest { + + private static final String PASSWORD = "TestPassword123!"; + + @LocalServerPort + private int port; + + @Autowired + private ObjectMapper mapper; + + @Autowired + private UserRepository userRepository; + + @Autowired + private PasswordEncoder passwordEncoder; + + private String username; + + @BeforeEach + void setUp() { + RestAssured.baseURI = "http://localhost"; + RestAssured.port = port; + + username = "test_" + UUID.randomUUID() + .toString().substring(0, 8); + + userRepository.saveAndFlush( + new User( + username, + "Test User", + passwordEncoder.encode(PASSWORD) + ) + ); + } + + private String login(String password) throws Exception { + String credentials = username + ":" + password; + + String basic = Base64.getEncoder().encodeToString( + credentials.getBytes(StandardCharsets.UTF_8) + ); + + var response = given() + .header("Authorization", "Basic " + basic) + .post("/api/v1/auth/sessions"); + + response.then().log().all(); + + response.then().statusCode(201); + + JsonNode json = mapper.readTree(response.asString()); + return json.get("token").asText(); + } + @Test + void validSessionAllowsAccess() throws Exception { + String token = login(PASSWORD); + + given() + .header("Authorization", "Bearer " + token) + .get("/api/v1/users/me") + .then() + .statusCode(200) + .body("username", equalTo(username)); + } + + @Test + void expiredSessionReturns401() throws Exception { + String token = login(PASSWORD); + + Thread.sleep(3000); + + given() + .header("Authorization", "Bearer " + token) + .get("/api/v1/users/me") + .then() + .statusCode(401); + } + + @Test + void logoutRevokesSession() throws Exception { + String token = login(PASSWORD); + + given() + .header("Authorization", "Bearer " + token) + .delete("/api/v1/auth/sessions/current") + .then() + .statusCode(204); + + given() + .header("Authorization", "Bearer " + token) + .get("/api/v1/users/me") + .then() + .statusCode(401); + } + + @Test + void wrongPasswordReturns401() { + String credentials = username + ":WrongPassword123!"; + + String basic = Base64.getEncoder().encodeToString( + credentials.getBytes(StandardCharsets.UTF_8) + ); + + given() + .header("Authorization", "Basic " + basic) + .post("/api/v1/auth/sessions") + .then() + .statusCode(401); + } + + @Test + void missingTokenReturns401() { + given() + .get("/api/v1/users/me") + .then() + .statusCode(401); + } + + @Test + void fakeUserIdHeaderCannotAuthenticate() { + given() + .header("X-User-Id", UUID.randomUUID().toString()) + .get("/api/v1/users/me") + .then() + .statusCode(401); + } +} diff --git a/java/src/test/java/com/vnp/demo/TransactionRollbackTest.java b/java/src/test/java/com/vnp/demo/TransactionRollbackTest.java new file mode 100644 index 0000000..6285d34 --- /dev/null +++ b/java/src/test/java/com/vnp/demo/TransactionRollbackTest.java @@ -0,0 +1,73 @@ +package com.vnp.demo; + +import com.vnp.demo.dto.ChatCreateRequest; +import com.vnp.demo.models.ChatMember; +import com.vnp.demo.models.User; +import com.vnp.demo.repositories.ChatMemberRepository; +import com.vnp.demo.repositories.ChatRepository; +import com.vnp.demo.repositories.UserRepository; +import com.vnp.demo.service.ChatService; + + +import org.springframework.boot.test.mock.mockito.SpyBean; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; + +import java.util.List; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@SpringBootTest +class TransactionRollbackTest { + + @Autowired + private ChatService chatService; + + @Autowired + private ChatRepository chatRepository; + + @Autowired + private UserRepository userRepository; + + @SpyBean + private ChatMemberRepository chatMemberRepository; + + @Test + void shouldRollbackChatCreationWhenMemberSaveFails() { + User user = userRepository.saveAndFlush( + new User( + "rollback_" + UUID.randomUUID() + .toString() + .substring(0, 8), + "Rollback Test", + "test-password-hash" + ) + ); + + long chatsBefore = chatRepository.count(); + + doThrow(new IllegalStateException("Simulated failure")) + .when(chatMemberRepository) + .save(any(ChatMember.class)); + + ChatCreateRequest request = new ChatCreateRequest( + "Rollback test chat", + List.of(user.getId()) + ); + + assertThrows( + IllegalStateException.class, + () -> chatService.create(user.getId(), request) + ); + + assertEquals( + chatsBefore, + chatRepository.count(), + "Chat must not be saved after transaction rollback" + ); + } +} diff --git a/java/src/test/java/com/vnp/demo/sql/message_index_benchmark.sql b/java/src/test/java/com/vnp/demo/sql/message_index_benchmark.sql new file mode 100644 index 0000000..8121735 --- /dev/null +++ b/java/src/test/java/com/vnp/demo/sql/message_index_benchmark.sql @@ -0,0 +1,89 @@ +BEGIN; + +INSERT INTO users ( + id, + username, + display_name, + password_hash +) +VALUES ( + '11111111-1111-4111-8111-111111111111', + 'benchmark_user', + 'Benchmark User', + 'benchmark-hash' +) +ON CONFLICT (id) DO NOTHING; + +INSERT INTO chats ( + id, + title +) +VALUES ( + '22222222-2222-4222-8222-222222222222', + 'Benchmark Chat' +) +ON CONFLICT (id) DO NOTHING; + +INSERT INTO chat_members ( + chat_id, + user_id +) +VALUES ( + '22222222-2222-4222-8222-222222222222', + '11111111-1111-4111-8111-111111111111' +) +ON CONFLICT DO NOTHING; + +INSERT INTO messages ( + id, + chat_id, + sender_id, + text, + created_at +) +SELECT + ( + '33333333-3333-4333-8333-' || + lpad(g::text, 12, '0') + )::uuid, + '22222222-2222-4222-8222-222222222222'::uuid, + '11111111-1111-4111-8111-111111111111'::uuid, + 'Benchmark message ' || g, + NOW() - INTERVAL '1 day' + + g * INTERVAL '1 second' +FROM generate_series(1, 10000) AS g +ON CONFLICT (id) DO NOTHING; + +COMMIT; + +ANALYZE messages; + +SELECT COUNT(*) +FROM messages +WHERE chat_id = + '22222222-2222-4222-8222-222222222222'; + +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = + '22222222-2222-4222-8222-222222222222' +ORDER BY created_at, id +LIMIT 50; + +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = + '22222222-2222-4222-8222-222222222222' + AND (created_at, id) > ( + ( + SELECT created_at + FROM messages + WHERE id = + '33333333-3333-4333-8333-000000000050' + ), + '33333333-3333-4333-8333-000000000050'::uuid + ) +ORDER BY created_at, id +LIMIT 50; \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 0000000..1b50c41 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,13 @@ +#!/bin/sh +set -eu + +cd "$(dirname "$0")/.." + +docker compose stop -t 20 api lb + +docker compose restart postgres redis + +docker compose up -d --no-deps --no-recreate \ + --wait --wait-timeout 30 postgres redis + +docker compose start api lb \ No newline at end of file diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 0000000..d8c94e9 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,46 @@ +#!/bin/sh +set -eu + +cd "$(dirname "$0")/.." + +: "${TARGET_INSTANCE_ID:?Не задан TARGET_INSTANCE_ID}" + +compose() { + docker compose --env-file .env -f compose.yml "$@" +} + +containers=$(compose ps --status running -q api) + +target="" +count=0 + +for container in $containers; do + count=$((count + 1)) + + instance_id=$(docker inspect \ + --format '{{.Config.Hostname}}' "$container") + + if [ "$instance_id" = "$TARGET_INSTANCE_ID" ]; then + if [ -n "$target" ]; then + printf '%s\n' 'Ошибка: найдено несколько подходящих реплик.' >&2 + exit 1 + fi + + target="$container" + fi +done + +if [ "$count" -lt 2 ]; then + printf '%s\n' 'Ошибка: должны работать минимум две API-реплики.' >&2 + exit 1 +fi + +if [ -z "$target" ]; then + printf '%s\n' 'Ошибка: указанная API-реплика не найдена.' >&2 + exit 1 +fi + + +docker kill --signal=KILL "$target" >/dev/null + +printf '%s\n' "Остановлена API-реплика: $TARGET_INSTANCE_ID" diff --git a/tests/level4_check.py b/tests/level4_check.py new file mode 100644 index 0000000..23cc257 --- /dev/null +++ b/tests/level4_check.py @@ -0,0 +1,177 @@ +#!/usr/bin/env python3 +"""Run from tests/ in lab3. Uses the unchanged skeleton client and resilience helpers. +Creates synthetic users/messages, stops only API containers, restores in finally. +Metrics are a small closed-loop workload, not a capacity benchmark. +""" +import csv +import json +import subprocess +import threading +import time +import uuid +from concurrent.futures import ThreadPoolExecutor +from datetime import datetime, timezone +from pathlib import Path +from client import Client, check +from resilience import history + +ROOT = Path(__file__).resolve().parents[1] +OUT = ROOT / 'results' / ('level4-' + datetime.now(timezone.utc).strftime('%Y%m%d-%H%M%S')) + + +def docker(*args): + p = subprocess.run(['docker', *args], cwd=ROOT, text=True, + capture_output=True, timeout=210) + check(p.returncode == 0, 'Docker command failed: ' + ' '.join(args)) + return p.stdout.strip() + + +def state(cid): + return json.loads(docker('inspect', '--format', '{{json .State}}', cid)) + + +def ready(cid): + deadline = time.monotonic() + 180 + while time.monotonic() < deadline: + s = state(cid) + if s.get('Running') and s.get('Health', {}).get('Status') == 'healthy': + return + time.sleep(1) + raise RuntimeError('API did not become healthy: ' + cid[:12]) + + +def observe(c, actor, expected): + deadline = time.monotonic() + 15 + seen = set() + while time.monotonic() < deadline: + try: + r = c.call('GET', '/api/v1/users/me', actor=actor, schema='User') + seen.add(r['headers']['X-Instance-Id']) + if expected <= seen: + return + except Exception: + pass + time.sleep(.1) + raise RuntimeError('Both actual API hostnames must be observed through LB') + + +def main(): + ids = docker('compose', 'ps', '--status', 'running', '-q', 'api').splitlines() + check(len(ids) == 2, 'Start exactly two healthy API replicas first') + names = {cid: docker('inspect', '--format', '{{.Config.Hostname}}', cid) for cid in ids} + for cid in ids: + ready(cid) + OUT.mkdir(parents=True) + summary = {'workload': '4 closed-loop workers, POST then GET, 50ms pause; HTTP timeout 2s', + 'replicas': names, 'experiments': []} + c = Client(timeout=2) + alice, bob, _, chat = c.bootstrap() + path = '/api/v1/chats/' + chat['id'] + '/messages?limit=100' + observe(c, alice, set(names.values())) + + # One key, eight requests released together; a fresh chat isolates this test. + barrier = threading.Barrier(8) + key = uuid.uuid4().hex + def replay(_): + local = Client(timeout=10) + barrier.wait(timeout=15) + r = local.message(alice, chat, 'parallel-' + key, key=key) + return {'instance': r['headers']['X-Instance-Id'], 'message': r['json']} + with ThreadPoolExecutor(max_workers=8) as pool: + replies = list(pool.map(replay, range(8))) + check(all(r['message'] == replies[0]['message'] for r in replies), 'Concurrent replies differ') + check(len({r['instance'] for r in replies}) == 2, 'Concurrency did not cover both replicas; rerun') + check(history(c, bob, chat) == [replies[0]['message']], 'Concurrent replay created duplicates') + summary['concurrency'] = {'pass': True, 'responses': replies} + print('PASS: parallel replay, two replicas, one message', flush=True) + + for cid in ids: + observe(c, alice, set(names.values())) + rows, confirmed = [], {} + halt = threading.Event() + lock = threading.Lock() + start = time.monotonic() + def worker(): + local = Client(timeout=2) + key = uuid.uuid4().hex + while not halt.is_set(): + # Preserve the key/body after any uncertain POST result. + for method in ('POST', 'GET'): + began = time.monotonic() + row = {'method': method, 'start': began - start, 'ok': False, 'instance': '', 'error': ''} + try: + if method == 'POST': + r = local.message(alice, chat, 'load-' + key, key=key) + with lock: + confirmed[r['json']['id']] = r['json'] + key = uuid.uuid4().hex + else: + r = local.call('GET', path, actor=alice, schema='MessagePage') + row.update(ok=True, instance=r['headers']['X-Instance-Id']) + except Exception as exc: + row['error'] = type(exc).__name__ + row['end'] = time.monotonic() - start + with lock: + rows.append(row) + halt.wait(.05) + pool = ThreadPoolExecutor(max_workers=4) + jobs = [pool.submit(worker) for _ in range(4)] + try: + time.sleep(5) + impact = time.monotonic() - start + docker('stop', '--timeout', '20', cid) + stopped = time.monotonic() - start + stopped_state = state(cid) + check(not stopped_state['Running'], 'Target is still running') + print('Stopped ' + names[cid] + '; measuring for 15 seconds', flush=True) + time.sleep(15) + finally: + halt.set() + pool.shutdown(wait=True) + # Restore even if HTTP validation or measurement fails. + docker('start', cid) + ready(cid) + for job in jobs: + job.result() + observe(c, alice, set(names.values())) + stored = history(c, bob, chat) + by_id = {m['id']: m for m in stored} + check(all(by_id.get(k) == v for k, v in confirmed.items()), 'Confirmed message lost') + texts = [m['text'] for m in stored] + check(len(texts) == len(set(texts)), 'Uncertain retry created duplicate') + end = max(r['end'] for r in rows) + def metrics(lo, hi): + selected = [r for r in rows if lo <= r['start'] < hi] + good = sum(r['ok'] for r in selected) + return {'seconds': round(hi-lo, 3), 'attempts': len(selected), 'errors': len(selected)-good, + 'attempt_rps': round(len(selected)/(hi-lo), 2), + 'success_rps': round(good/(hi-lo), 2)} + recovery = {} + for method in ('POST', 'GET'): + hits = [r['end']-impact for r in rows if r['method'] == method and r['ok'] + and r['start'] >= stopped and r['instance'] != names[cid]] + recovery[method] = round(min(hits), 3) if hits else None + result = {'target': names[cid], 'exit_code': stopped_state['ExitCode'], + 'stop_started_seconds': impact, 'stop_finished_seconds': stopped, + 'baseline': metrics(0, impact), 'during_and_after_stop': metrics(impact, end), + 'first_success_after_stop_seconds_from_action_start': recovery, + 'confirmed_messages_preserved': True} + summary['experiments'].append(result) + with (OUT / (names[cid] + '.csv')).open('w', newline='') as f: + w = csv.DictWriter(f, fieldnames=list(rows[0])) + w.writeheader() + w.writerows(rows) + (OUT / 'summary.json').write_text(json.dumps(summary, indent=2), encoding='utf-8') + print(json.dumps(result, indent=2), flush=True) + check(all(v is not None and v <= 10 for v in recovery.values()), 'Read/write recovery exceeded 10s') + print('PASS: replica restored, session and data preserved', flush=True) + print('Results:', OUT) + print('This checks SIGTERM failover and concurrency, NOT rolling replacement.') + + +if __name__ == '__main__': + try: + main() + except Exception as exc: + print('FAIL:', str(exc)) + raise SystemExit(1)