Move lab2 to lab3

This commit is contained in:
2026-10-22 20:21:52 +03:00
parent 0ab3a341aa
commit a3dbcd6ba4
135 changed files with 5897 additions and 0 deletions
+18
View File
@@ -18,3 +18,21 @@ __pycache__
node_modules
evidence
.DS_Store
.gradle
.kotlin
build
.idea
*.iml
tests
scripts
examples
run
COURSE.md
CONTRIBUTING.md
MAINTAINERS.md
REPORT.md
README.md
requirements-dev.txt
Dockerfile.example
compose.example.yaml
Makefile
+4
View File
@@ -28,5 +28,9 @@ coverage/
.DS_Store
.idea/
.vscode/
.gradle/
.kotlin/
!gradle/wrapper/
/run/development/
# Keep small, sanitized evidence summaries in evidence/ under version control.
# Inspect git diff --cached: ignore rules are not a secret scanner.
+19
View File
@@ -0,0 +1,19 @@
FROM gradle:8.14-jdk21 AS build
WORKDIR /src
COPY settings.gradle.kts build.gradle.kts gradle.properties ./
COPY gradle ./gradle
COPY gradlew ./
COPY src ./src
COPY contracts ./contracts
RUN --mount=type=cache,target=/home/gradle/.gradle gradle --no-daemon shadowJar
FROM eclipse-temurin:21-jre-alpine
RUN apk add --no-cache wget && addgroup -S app && adduser -S -G app app
WORKDIR /app
COPY --from=build /src/build/libs/messenger.jar /app/messenger.jar
USER app
ENV APP_HOST=0.0.0.0 APP_PORT=8080
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=15s --retries=3 \
CMD wget -qO- http://127.0.0.1:8080/health/ready || exit 1
ENTRYPOINT ["java","-XX:MaxRAMPercentage=75.0","-jar","/app/messenger.jar"]
+115
View File
@@ -0,0 +1,115 @@
plugins {
alias(libs.plugins.kotlin)
alias(libs.plugins.kotlin.serialization)
alias(libs.plugins.ksp)
alias(libs.plugins.shadow)
id("application")
}
group = "com.mtusi.messenger"
version = "2.0.0"
repositories {
mavenCentral()
}
dependencies {
implementation(libs.kotlinx.serialization.json)
implementation(libs.kotlinx.serialization.hocon)
implementation(libs.logback.classic)
implementation(ktorLibs.server.core)
implementation(ktorLibs.server.netty)
implementation(ktorLibs.server.auth)
implementation(ktorLibs.server.contentNegotiation)
implementation(ktorLibs.server.statusPages)
implementation(ktorLibs.server.callLogging)
implementation(ktorLibs.server.defaultHeaders)
implementation(ktorLibs.server.swagger)
implementation(ktorLibs.serialization.kotlinx.json)
implementation(libs.koin.core)
implementation(libs.koin.ktor)
implementation(libs.koin.annotations)
ksp(libs.koin.compiler)
implementation(libs.exposed.core)
implementation(libs.exposed.jdbc)
implementation(libs.exposed.kotlin.datetime)
implementation(libs.exposed.migration.core)
implementation(libs.exposed.migration.jdbc)
implementation(libs.postgres)
implementation(libs.hikaricp)
implementation(libs.flyway)
implementation(libs.flyway.postgresql)
implementation(libs.lettuce)
implementation(libs.bouncycastle)
testImplementation(kotlin("test"))
testImplementation(ktorLibs.server.testHost)
testImplementation(ktorLibs.client.contentNegotiation)
testImplementation(libs.kotlinx.coroutines.test)
testImplementation(libs.koin.test)
testImplementation(libs.testContainers)
testImplementation(libs.testContainers.postgresql)
}
kotlin {
jvmToolchain(21)
}
ksp {
arg("KOIN_CONFIG_CHECK", "true")
arg("KOIN_DEFAULT_MODULE", "false")
}
application {
mainClass = "io.ktor.server.netty.EngineMain"
applicationDefaultJvmArgs = listOf("-Dio.ktor.development=false")
}
sourceSets {
named("main") {
resources {
srcDir(layout.projectDirectory.dir("contracts"))
}
}
}
tasks {
test {
useJUnitPlatform()
}
shadowJar {
archiveBaseName = "messenger"
archiveClassifier = ""
archiveVersion = ""
mergeServiceFiles()
}
getByName<JavaExec>("run") {
val configArgs = File("run/development/config")
.listFiles()
?.filter { it.extension == "conf" }
?.map {
"-config=config/${it.name}"
}
?: emptyList()
args = configArgs
workingDir = file("run/development")
}
register<JavaExec>("generateMigration") {
group = "database"
description = "Generates a new migration"
classpath = sourceSets["main"].runtimeClasspath
mainClass.set("com.mtusi.messenger.main.plugins.DatabaseKt")
}
}
+87
View File
@@ -0,0 +1,87 @@
name: mtusi-messenger-lab3
services:
postgres:
image: postgres:17.6-alpine3.22
container_name: mtusi-lab3-postgres
# pg_stat_statements counts executed queries, track 1 uses it to measure the cache stampede.
command: ["postgres", "-c", "shared_preload_libraries=pg_stat_statements", "-c", "pg_stat_statements.track=all"]
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/db_password
secrets:
- db_password
volumes:
- postgres-data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 10
start_period: 10s
restart: unless-stopped
redis:
image: redis:8.4.0-alpine
container_name: mtusi-lab3-redis
# Session cache only, PostgreSQL is the source of truth: no RDB/AOF, a restart simply empties the cache.
# Every key carries a TTL, so under memory pressure volatile-lru evicts the least used sessions.
command:
- sh
- -c
- >-
exec docker-entrypoint.sh redis-server
--requirepass "$$(cat /run/secrets/redis_password)"
--save ""
--appendonly no
--maxmemory 64mb
--maxmemory-policy volatile-lru
secrets:
- redis_password
healthcheck:
test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/redis_password)\" redis-cli ping | grep -q PONG"]
interval: 5s
timeout: 3s
retries: 10
start_period: 5s
restart: unless-stopped
api:
build: .
image: mtusi-messenger:lab3
container_name: mtusi-lab3-api
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
environment:
APP_HOST: "0.0.0.0"
APP_PORT: "8080"
DB_HOST: postgres
DB_PORT: "5432"
DB_NAME: messenger
DB_USER: messenger
DB_PASSWORD_FILE: /run/secrets/db_password
REDIS_HOST: redis
REDIS_PORT: "6379"
REDIS_PASSWORD_FILE: /run/secrets/redis_password
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_CACHE_SINGLE_FLIGHT: ${SESSION_CACHE_SINGLE_FLIGHT:-true}
secrets:
- db_password
- redis_password
ports:
- "127.0.0.1:8080:8080"
restart: unless-stopped
secrets:
db_password:
file: ./secrets/db_password
redis_password:
file: ./secrets/redis_password
volumes:
postgres-data:
+1
View File
@@ -0,0 +1 @@
kotlin.code.style=official
+54
View File
@@ -0,0 +1,54 @@
[versions]
kotlin = "2.3.20"
ksp = "2.3.0"
kotlinx-serialization = "1.10.0"
kotlinx-coroutines = "1.9.0"
logback = "1.5.13"
shadow = "8.3.5"
koin = "4.1.0-RC1"
koin-ktor = "4.1.0-Beta8"
koin-compiler = "2.0.0"
exposed = "1.0.0"
postgres = "42.7.3"
hikaricp = "6.3.0"
flyway = "11.9.0"
lettuce = "6.7.1.RELEASE"
bouncycastle = "1.81"
test-containers = "1.21.0"
[plugins]
kotlin = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
shadow = { id = "com.gradleup.shadow", version.ref = "shadow" }
[libraries]
kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
kotlinx-serialization-hocon = { module = "org.jetbrains.kotlinx:kotlinx-serialization-hocon", version.ref = "kotlinx-serialization" }
kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
koin-core = { module = "io.insert-koin:koin-core", version.ref = "koin" }
koin-ktor = { module = "io.insert-koin:koin-ktor3", version.ref = "koin-ktor" }
koin-annotations = { module = "io.insert-koin:koin-annotations", version.ref = "koin-compiler" }
koin-compiler = { module = "io.insert-koin:koin-ksp-compiler", version.ref = "koin-compiler" }
koin-test = { module = "io.insert-koin:koin-test", version.ref = "koin" }
exposed-core = { module = "org.jetbrains.exposed:exposed-core", version.ref = "exposed" }
exposed-jdbc = { module = "org.jetbrains.exposed:exposed-jdbc", version.ref = "exposed" }
exposed-kotlin-datetime = { module = "org.jetbrains.exposed:exposed-kotlin-datetime", version.ref = "exposed" }
exposed-migration-core = { module = "org.jetbrains.exposed:exposed-migration-core", version.ref = "exposed" }
exposed-migration-jdbc = { module = "org.jetbrains.exposed:exposed-migration-jdbc", version.ref = "exposed" }
postgres = { module = "org.postgresql:postgresql", version.ref = "postgres" }
hikaricp = { module = "com.zaxxer:HikariCP", version.ref = "hikaricp" }
flyway = { module = "org.flywaydb:flyway-core", version.ref = "flyway" }
flyway-postgresql = { module = "org.flywaydb:flyway-database-postgresql", version.ref = "flyway" }
lettuce = { module = "io.lettuce:lettuce-core", version.ref = "lettuce" }
bouncycastle = { module = "org.bouncycastle:bcprov-jdk18on", version.ref = "bouncycastle" }
testContainers = { module = "org.testcontainers:testcontainers", version.ref = "test-containers" }
testContainers-postgresql = { module = "org.testcontainers:postgresql", version.ref = "test-containers" }
Binary file not shown.
+7
View File
@@ -0,0 +1,7 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-bin.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
Vendored Executable
+251
View File
@@ -0,0 +1,251 @@
#!/bin/sh
#
# Copyright © 2015-2021 the original authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# SPDX-License-Identifier: Apache-2.0
#
##############################################################################
#
# Gradle start up script for POSIX generated by Gradle.
#
# Important for running:
#
# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
# noncompliant, but you have some other compliant shell such as ksh or
# bash, then to run this script, type that shell name before the whole
# command line, like:
#
# ksh Gradle
#
# Busybox and similar reduced shells will NOT work, because this script
# requires all of these POSIX shell features:
# * functions;
# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
# * compound commands having a testable exit status, especially «case»;
# * various built-in commands including «command», «set», and «ulimit».
#
# Important for patching:
#
# (2) This script targets any POSIX shell, so it avoids extensions provided
# by Bash, Ksh, etc; in particular arrays are avoided.
#
# The "traditional" practice of packing multiple parameters into a
# space-separated string is a well documented source of bugs and security
# problems, so this is (mostly) avoided, by progressively accumulating
# options in "$@", and eventually passing that to Java.
#
# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
# see the in-line comments for details.
#
# There are tweaks for specific operating systems such as AIX, CygWin,
# Darwin, MinGW, and NonStop.
#
# (3) This script is generated from the Groovy template
# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
# within the Gradle project.
#
# You can find Gradle at https://github.com/gradle/gradle/.
#
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
app_path=$0
# Need this for daisy-chained symlinks.
while
APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
[ -h "$app_path" ]
do
ls=$( ls -ld "$app_path" )
link=${ls#*' -> '}
case $link in #(
/*) app_path=$link ;; #(
*) app_path=$APP_HOME$link ;;
esac
done
# This is normally unused
# shellcheck disable=SC2034
APP_BASE_NAME=${0##*/}
# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD=maximum
warn () {
echo "$*"
} >&2
die () {
echo
echo "$*"
echo
exit 1
} >&2
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "$( uname )" in #(
CYGWIN* ) cygwin=true ;; #(
Darwin* ) darwin=true ;; #(
MSYS* | MINGW* ) msys=true ;; #(
NONSTOP* ) nonstop=true ;;
esac
CLASSPATH="\\\"\\\""
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD=$JAVA_HOME/jre/sh/java
else
JAVACMD=$JAVA_HOME/bin/java
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD=java
if ! command -v java >/dev/null 2>&1
then
die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
fi
# Increase the maximum file descriptors if we can.
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
case $MAX_FD in #(
max*)
# In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
# shellcheck disable=SC2039,SC3045
MAX_FD=$( ulimit -H -n ) ||
warn "Could not query maximum file descriptor limit"
esac
case $MAX_FD in #(
'' | soft) :;; #(
*)
# In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
# shellcheck disable=SC2039,SC3045
ulimit -n "$MAX_FD" ||
warn "Could not set maximum file descriptor limit to $MAX_FD"
esac
fi
# Collect all arguments for the java command, stacking in reverse order:
# * args from the command line
# * the main class name
# * -classpath
# * -D...appname settings
# * --module-path (only if needed)
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
JAVACMD=$( cygpath --unix "$JAVACMD" )
# Now convert the arguments - kludge to limit ourselves to /bin/sh
for arg do
if
case $arg in #(
-*) false ;; # don't mess with options #(
/?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
[ -e "$t" ] ;; #(
*) false ;;
esac
then
arg=$( cygpath --path --ignore --mixed "$arg" )
fi
# Roll the args list around exactly as many times as the number of
# args, so each arg winds up back in the position where it started, but
# possibly modified.
#
# NB: a `for` loop captures its iteration list before it begins, so
# changing the positional parameters here affects neither the number of
# iterations, nor the values presented in `arg`.
shift # remove old arg
set -- "$@" "$arg" # push replacement arg
done
fi
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Collect all arguments for the java command:
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
# and any embedded shellness will be escaped.
# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
# treated as '${Hostname}' itself on the command line.
set -- \
"-Dorg.gradle.appname=$APP_BASE_NAME" \
-classpath "$CLASSPATH" \
-jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
"$@"
# Stop when "xargs" is not available.
if ! command -v xargs >/dev/null 2>&1
then
die "xargs is not available"
fi
# Use "xargs" to parse quoted args.
#
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
#
# In Bash we could simply go:
#
# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
# set -- "${ARGS[@]}" "$@"
#
# but POSIX shell has neither arrays nor command substitution, so instead we
# post-process each arg (as a line of input to sed) to backslash-escape any
# character that might be a shell metacharacter, then use eval to reverse
# that process (while maintaining the separation between arguments), and wrap
# the whole thing up as a single "set" statement.
#
# This will of course break if any of these variables contains a newline or
# an unmatched quote.
#
eval "set -- $(
printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
xargs -n1 |
sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
tr '\n' ' '
)" '"$@"'
exec "$JAVACMD" "$@"
Vendored
+94
View File
@@ -0,0 +1,94 @@
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem https://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@rem SPDX-License-Identifier: Apache-2.0
@rem
@if "%DEBUG%"=="" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%"=="" set DIRNAME=.
@rem This is normally unused
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if %ERRORLEVEL% equ 0 goto execute
echo. 1>&2
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto execute
echo. 1>&2
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2
goto fail
:execute
@rem Setup the command line
set CLASSPATH=
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
:end
@rem End local scope for the variables with windows NT shell
if %ERRORLEVEL% equ 0 goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
set EXIT_CODE=%ERRORLEVEL%
if %EXIT_CODE% equ 0 set EXIT_CODE=1
if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
exit /b %EXIT_CODE%
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega
+12
View File
@@ -0,0 +1,12 @@
ktor {
application {
modules = [com.mtusi.messenger.main.AppKt.module]
}
deployment {
host = "127.0.0.1"
port = 8080
}
}
+4
View File
@@ -0,0 +1,4 @@
authentication {
realm = "messenger"
sessionTtlSeconds = 3600
}
+9
View File
@@ -0,0 +1,9 @@
database {
host = "localhost"
port = 5432
name = "messenger"
username = "username"
password = "password"
maxPoolSize = 10
connectionTimeoutMs = 2000
}
+6
View File
@@ -0,0 +1,6 @@
redis {
host = "localhost"
port = 6379
connectTimeoutMs = 500
commandTimeoutMs = 500
}
+10
View File
@@ -0,0 +1,10 @@
#!/bin/sh
# Runs EXPLAIN (ANALYZE, BUFFERS) of the chat history query against the Compose PostgreSQL on 70 000 synthetic
# messages. The data is inserted and rolled back in one transaction; the plans are saved to evidence/.
set -eu
cd "$(dirname "$0")/.."
mkdir -p evidence
docker compose exec -T postgres psql -U messenger -d messenger -X -q < scripts/sql/explain-history.sql \
| tee evidence/explain-history.txt
+19
View File
@@ -0,0 +1,19 @@
#!/bin/sh
# Creates local secrets for the Compose stack. Never overwrites an existing secret:
# the PostgreSQL volume is initialised with the first password and keeps it.
set -eu
cd "$(dirname "$0")/.."
mkdir -p secrets
# Readable by the non-root users inside the containers (bind-mounted as is).
umask 022
for name in db_password redis_password; do
if [ ! -s "secrets/$name" ]; then
openssl rand -hex 24 > "secrets/$name"
echo "created secrets/$name"
else
echo "secrets/$name already exists, keeping it"
fi
done
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
# Restarts the API, PostgreSQL and Redis, keeping the named volume (no `down -v`, no re-seed).
set -eu
cd "$(dirname "$0")/.."
docker compose stop api redis postgres
docker compose up -d --wait postgres redis api
+100
View File
@@ -0,0 +1,100 @@
-- EXPLAIN (ANALYZE, BUFFERS) of the chat history query on synthetic data.
-- Everything runs in one transaction that is rolled back: the database is left untouched.
-- The queries are the ones ExposedMessageRepository.findPageByChatId generates (page size 50 + 1 look-ahead row).
\set ON_ERROR_STOP on
\pset pager off
BEGIN;
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ('00000000-0000-0000-0000-000000000001', 'explain_alice', 'Alice', 'not-a-hash', now()),
('00000000-0000-0000-0000-000000000002', 'explain_bob', 'Bob', 'not-a-hash', now());
-- One large chat (20 000 messages) and 50 neighbours with 1 000 messages each: 70 000 rows in total,
-- so the plan has to skip foreign chats instead of reading a table that only holds the target chat.
INSERT INTO chats (id, title, created_at)
SELECT ('00000000-0000-0000-0001-' || lpad(n::text, 12, '0'))::uuid, 'explain chat ' || n, now()
FROM generate_series(0, 50) AS n;
INSERT INTO chat_members (chat_id, user_id, position)
SELECT c.id, u.id, u.position
FROM chats c
CROSS JOIN (VALUES ('00000000-0000-0000-0000-000000000001'::uuid, 0),
('00000000-0000-0000-0000-000000000002'::uuid, 1)) AS u (id, position)
WHERE c.title LIKE 'explain chat %';
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(),
'00000000-0000-0000-0001-000000000000',
CASE WHEN n % 2 = 0 THEN '00000000-0000-0000-0000-000000000001'::uuid
ELSE '00000000-0000-0000-0000-000000000002'::uuid END,
'message #' || n,
timestamptz '2026-01-01 00:00:00+00' + n * interval '1 second'
FROM generate_series(1, 20000) AS n;
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(),
('00000000-0000-0000-0001-' || lpad(c::text, 12, '0'))::uuid,
'00000000-0000-0000-0000-000000000001',
'neighbour message #' || n,
timestamptz '2026-01-01 00:00:00+00' + n * interval '1 second'
FROM generate_series(1, 50) AS c, generate_series(1, 1000) AS n;
ANALYZE users, chats, chat_members, messages;
\echo
\echo '== Data volume'
SELECT count(*) AS total_messages,
count(*) FILTER (WHERE chat_id = '00000000-0000-0000-0001-000000000000') AS target_chat_messages
FROM messages;
-- Cursor of the 15 000th message: a deep page, where OFFSET pagination would have to skip 15 000 rows.
SELECT created_at AS cursor_created_at, id AS cursor_id
FROM messages
WHERE chat_id = '00000000-0000-0000-0001-000000000000'
ORDER BY created_at, id
OFFSET 14999 LIMIT 1 \gset
\echo
\echo '== 1. First page: WHERE chat_id = ? ORDER BY created_at, id LIMIT 51'
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
SELECT messages.id, messages.chat_id, messages.sender_id, messages.text, messages.created_at
FROM messages
WHERE messages.chat_id = '00000000-0000-0000-0001-000000000000'
ORDER BY messages.created_at ASC, messages.id ASC
LIMIT 51;
\echo
\echo '== 2. Deep page after the 15 000th message: (created_at, id) > (?, ?)'
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
SELECT messages.id, messages.chat_id, messages.sender_id, messages.text, messages.created_at
FROM messages
WHERE (messages.chat_id = '00000000-0000-0000-0001-000000000000')
AND ((messages.created_at, messages.id) > (:'cursor_created_at', :'cursor_id'))
ORDER BY messages.created_at ASC, messages.id ASC
LIMIT 51;
\echo
\echo '== 3. Same deep page with OFFSET instead of a cursor (for comparison, not used by the API)'
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
SELECT messages.id, messages.chat_id, messages.sender_id, messages.text, messages.created_at
FROM messages
WHERE messages.chat_id = '00000000-0000-0000-0001-000000000000'
ORDER BY messages.created_at ASC, messages.id ASC
LIMIT 51 OFFSET 15000;
\echo
\echo '== 4. Deep page without messages_chat_id_created_at_id_idx (index scans disabled for this query only)'
SET LOCAL enable_indexscan = off;
SET LOCAL enable_bitmapscan = off;
SET LOCAL enable_indexonlyscan = off;
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
SELECT messages.id, messages.chat_id, messages.sender_id, messages.text, messages.created_at
FROM messages
WHERE (messages.chat_id = '00000000-0000-0000-0001-000000000000')
AND ((messages.created_at, messages.id) > (:'cursor_created_at', :'cursor_id'))
ORDER BY messages.created_at ASC, messages.id ASC
LIMIT 51;
ROLLBACK;
+17
View File
@@ -0,0 +1,17 @@
dependencyResolutionManagement {
repositories {
mavenCentral()
}
versionCatalogs {
create("ktorLibs") {
from("io.ktor:ktor-version-catalog:3.3.0")
}
}
}
plugins {
id("org.gradle.toolchains.foojay-resolver-convention") version "1.0.0"
}
rootProject.name = "mtusi-messenger-lab3"
@@ -0,0 +1,33 @@
package com.mtusi.messenger.main
import com.mtusi.messenger.main.plugins.authentication.configureAuthentication
import com.mtusi.messenger.main.plugins.configureCallLogging
import com.mtusi.messenger.main.plugins.configureContentNegotiation
import com.mtusi.messenger.main.plugins.configureDatabase
import com.mtusi.messenger.main.plugins.configureDefaultHeaders
import com.mtusi.messenger.main.plugins.configureKoin
import com.mtusi.messenger.main.plugins.configureRedis
import com.mtusi.messenger.main.plugins.configureRequestId
import com.mtusi.messenger.main.plugins.configureRouting
import com.mtusi.messenger.main.plugins.configureStatusPages
import io.ktor.server.application.Application
import io.ktor.server.netty.EngineMain
fun main(args: Array<String>): Unit = EngineMain.main(args)
fun Application.module() {
configureKoin()
configureDatabase()
configureRedis()
configureContentNegotiation()
configureDefaultHeaders()
configureRequestId()
configureCallLogging()
configureStatusPages()
configureAuthentication()
configureRouting()
}
@@ -0,0 +1,31 @@
package com.mtusi.messenger.main.compat.serializers
import kotlinx.serialization.KSerializer
import kotlinx.serialization.Serializable
import kotlinx.serialization.descriptors.PrimitiveKind
import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
import kotlinx.serialization.encoding.Decoder
import kotlinx.serialization.encoding.Encoder
import java.util.UUID
typealias SerialUUID = @Serializable(UUIDSerializer::class) UUID
object UUIDSerializer : KSerializer<UUID> {
override val descriptor = PrimitiveSerialDescriptor(
serialName = "UUID",
kind = PrimitiveKind.STRING
)
override fun deserialize(decoder: Decoder): UUID {
return decoder.decodeString().run(UUID::fromString)
}
override fun serialize(
encoder: Encoder,
value: UUID
) {
encoder.encodeString(value.toString())
}
}
@@ -0,0 +1,8 @@
package com.mtusi.messenger.main.config
import org.koin.core.annotation.ComponentScan
import org.koin.core.annotation.Module
@Module(createdAtStart = true)
@ComponentScan
class ConfigModule
@@ -0,0 +1,10 @@
package com.mtusi.messenger.main.config.authentication
interface AuthenticationConfig {
val realm: String
val sessionTtlSeconds: Long
val sessionCacheTtlSeconds: Long
val sessionCacheSingleFlight: Boolean
}
@@ -0,0 +1,11 @@
package com.mtusi.messenger.main.config.authentication
import io.ktor.server.application.Application
import io.ktor.server.config.getAs
import org.koin.core.annotation.Provided
import org.koin.core.annotation.Single
@Single
class DefaultAuthenticationConfig(
@Provided app: Application
) : AuthenticationConfig by app.environment.config.property("authentication").getAs<SerialAuthenticationConfig>()
@@ -0,0 +1,11 @@
package com.mtusi.messenger.main.config.authentication
import kotlinx.serialization.Serializable
@Serializable
data class SerialAuthenticationConfig(
override val realm: String,
override val sessionTtlSeconds: Long,
override val sessionCacheTtlSeconds: Long,
override val sessionCacheSingleFlight: Boolean = true
) : AuthenticationConfig
@@ -0,0 +1,20 @@
package com.mtusi.messenger.main.config.database
interface DatabaseConfig {
val host: String
val port: Int
val name: String
val username: String
val password: String?
val passwordFile: String?
val maxPoolSize: Int
val connectionTimeoutMs: Long
val statementTimeoutMs: Long
val jdbcConnectionUrl: String
get() = "jdbc:postgresql://$host:$port/$name"
}
@@ -0,0 +1,11 @@
package com.mtusi.messenger.main.config.database
import io.ktor.server.application.Application
import io.ktor.server.config.getAs
import org.koin.core.annotation.Provided
import org.koin.core.annotation.Single
@Single
class DefaultDatabaseConfig(
@Provided app: Application
) : DatabaseConfig by app.environment.config.property("database").getAs<SerialDatabaseConfig>()
@@ -0,0 +1,16 @@
package com.mtusi.messenger.main.config.database
import kotlinx.serialization.Serializable
@Serializable
data class SerialDatabaseConfig(
override val host: String,
override val port: Int,
override val name: String,
override val username: String,
override val password: String? = null,
override val passwordFile: String? = null,
override val maxPoolSize: Int,
override val connectionTimeoutMs: Long,
override val statementTimeoutMs: Long
) : DatabaseConfig
@@ -0,0 +1,11 @@
package com.mtusi.messenger.main.config.redis
import io.ktor.server.application.Application
import io.ktor.server.config.getAs
import org.koin.core.annotation.Provided
import org.koin.core.annotation.Single
@Single
class DefaultRedisConfig(
@Provided app: Application
) : RedisConfig by app.environment.config.property("redis").getAs<SerialRedisConfig>()
@@ -0,0 +1,15 @@
package com.mtusi.messenger.main.config.redis
interface RedisConfig {
val host: String
val port: Int
val username: String?
val password: String?
val passwordFile: String?
val connectTimeoutMs: Long
val commandTimeoutMs: Long
}
@@ -0,0 +1,14 @@
package com.mtusi.messenger.main.config.redis
import kotlinx.serialization.Serializable
@Serializable
data class SerialRedisConfig(
override val host: String,
override val port: Int,
override val username: String? = null,
override val password: String? = null,
override val passwordFile: String? = null,
override val connectTimeoutMs: Long,
override val commandTimeoutMs: Long
) : RedisConfig
@@ -0,0 +1,37 @@
package com.mtusi.messenger.main.extensions
import com.mtusi.messenger.main.infrastructure.types.AuthChallenge
import com.mtusi.messenger.main.infrastructure.types.ErrorCode
import com.mtusi.messenger.main.plugins.RequestIdKey
import com.mtusi.messenger.main.plugins.authentication.UserPrincipal
import io.ktor.http.HttpHeaders
import io.ktor.server.application.ApplicationCall
import io.ktor.server.auth.principal
import io.ktor.server.response.header
import io.ktor.server.response.respond
import kotlinx.serialization.Serializable
@Serializable
data class ErrorBody(val error: ErrorDetails)
@Serializable
data class ErrorDetails(
val code: String,
val message: String,
val requestId: String,
)
suspend fun ApplicationCall.respondError(
code: ErrorCode,
message: String,
challenge: String = AuthChallenge.BEARER,
) {
val requestId = attributes[RequestIdKey]
if (code == ErrorCode.UNAUTHORIZED) {
response.header(HttpHeaders.WWWAuthenticate, challenge)
}
respond(code.status, ErrorBody(ErrorDetails(code.wire, message, requestId)))
}
val ApplicationCall.currentUser: UserPrincipal
get() = principal<UserPrincipal>()!!
@@ -0,0 +1,31 @@
package com.mtusi.messenger.main.infrastructure.controllers._common.parameters
import com.mtusi.messenger.main.infrastructure.types.ApiException
import com.mtusi.messenger.main.infrastructure.types.ErrorCode
import io.ktor.server.application.ApplicationCall
private const val DEFAULT_LIMIT = 50
private const val MAX_LIMIT = 100
data class PageParameters(
val limit: Int,
val cursor: String?
)
fun ApplicationCall.pageParameters(): PageParameters {
val query = request.queryParameters
val limit = query["limit"]
?.let { it.toIntOrNull() ?: throw ApiException(ErrorCode.INVALID_REQUEST, "invalid limit") }
?: DEFAULT_LIMIT
if (limit !in 1..MAX_LIMIT) {
throw ApiException(ErrorCode.INVALID_REQUEST, "limit out of range")
}
val cursor = query["cursor"]
?.takeIf { it.isNotEmpty() }
return PageParameters(limit, cursor)
}
@@ -0,0 +1,53 @@
package com.mtusi.messenger.main.infrastructure.controllers.authentication
import com.mtusi.messenger.main.extensions.currentUser
import com.mtusi.messenger.main.infrastructure.controllers.authentication.responses.SessionResponse
import com.mtusi.messenger.main.infrastructure.services.authentication.AuthenticationService
import com.mtusi.messenger.main.plugins.authentication.CREDENTIALS_AUTH
import com.mtusi.messenger.main.plugins.authentication.CredentialsPrincipal
import com.mtusi.messenger.main.plugins.authentication.SESSION_AUTH
import com.mtusi.messenger.main.plugins.suspendedTransaction
import io.ktor.http.HttpStatusCode
import io.ktor.server.auth.authenticate
import io.ktor.server.auth.principal
import io.ktor.server.response.respond
import io.ktor.server.routing.Routing
import io.ktor.server.routing.delete
import io.ktor.server.routing.post
import io.ktor.server.routing.route
import org.koin.ktor.ext.inject
fun Routing.configureAuthenticationRouting() = route("/api/v1/auth/sessions") {
val authenticationService by inject<AuthenticationService>()
authenticate(CREDENTIALS_AUTH) {
post {
val (user) = call.principal<CredentialsPrincipal>()!!
val issued = suspendedTransaction {
authenticationService.createSession(user.id)
}
call.respond(
HttpStatusCode.Created,
SessionResponse(
token = issued.token,
expiresAt = issued.session.expiresAt,
user = user
)
)
}
}
authenticate(SESSION_AUTH) {
delete("current") {
authenticationService.revokeSession(call.currentUser.session)
call.respond(HttpStatusCode.NoContent)
}
}
}
@@ -0,0 +1,13 @@
package com.mtusi.messenger.main.infrastructure.controllers.authentication.responses
import com.mtusi.messenger.main.infrastructure.dto.User
import kotlinx.serialization.Serializable
import kotlin.time.Instant
@Serializable
data class SessionResponse(
val token: String,
val tokenType: String = "Bearer",
val expiresAt: Instant,
val user: User,
)
@@ -0,0 +1,112 @@
package com.mtusi.messenger.main.infrastructure.controllers.chat
import com.mtusi.messenger.main.extensions.currentUser
import com.mtusi.messenger.main.extensions.respondError
import com.mtusi.messenger.main.infrastructure.controllers._common.parameters.pageParameters
import com.mtusi.messenger.main.infrastructure.controllers.chat.requests.CreateChatRequest
import com.mtusi.messenger.main.infrastructure.models.chat.MAX_CHAT_MEMBERS
import com.mtusi.messenger.main.infrastructure.models.chat.MAX_CHAT_TITLE_LENGTH
import com.mtusi.messenger.main.infrastructure.services.chat.ChatService
import com.mtusi.messenger.main.infrastructure.services.chat.results.ChatCreationResult
import com.mtusi.messenger.main.infrastructure.services.chat.results.ChatPageResult
import com.mtusi.messenger.main.infrastructure.types.ApiException
import com.mtusi.messenger.main.infrastructure.types.ErrorCode
import com.mtusi.messenger.main.plugins.authentication.SESSION_AUTH
import com.mtusi.messenger.main.plugins.suspendedTransaction
import com.mtusi.messenger.main.utils.requireNonBlankBounded
import com.mtusi.messenger.main.utils.requireUuid
import io.ktor.http.HttpStatusCode
import io.ktor.server.auth.authenticate
import io.ktor.server.request.receive
import io.ktor.server.response.respond
import io.ktor.server.routing.Routing
import io.ktor.server.routing.get
import io.ktor.server.routing.post
import io.ktor.server.routing.route
import org.koin.ktor.ext.inject
fun Routing.configureChatRouting() = route("/api/v1/chats") {
val chatService by inject<ChatService>()
authenticate(SESSION_AUTH) {
post {
val actor = call.currentUser
val body = call.receive<CreateChatRequest>()
requireNonBlankBounded(
body.title,
min = 1,
max = MAX_CHAT_TITLE_LENGTH,
field = "title"
)
if (body.memberIds.isEmpty() || body.memberIds.size > MAX_CHAT_MEMBERS) {
throw ApiException(ErrorCode.INVALID_REQUEST, "member_ids size out of range")
}
val memberIds = body.memberIds.map { requireUuid(it, "member_ids") }
val result = suspendedTransaction {
chatService.create(
creatorId = actor.id,
title = body.title,
memberIds = memberIds
)
}
when (result) {
is ChatCreationResult.DuplicateMembers ->
call.respondError(ErrorCode.INVALID_REQUEST, "member_ids must be unique")
is ChatCreationResult.CreatorNotMember ->
call.respondError(ErrorCode.INVALID_REQUEST, "creator must be in member ids")
is ChatCreationResult.UnknownMembers ->
call.respondError(ErrorCode.INVALID_REQUEST, "unknown member")
is ChatCreationResult.Success ->
call.respond(HttpStatusCode.Created, result.chat)
}
}
get {
val actor = call.currentUser
val (limit, cursor) = call.pageParameters()
val result = suspendedTransaction {
chatService.findPageAccessible(
userId = actor.id,
limit = limit,
cursor = cursor
)
}
when (result) {
is ChatPageResult.InvalidCursor ->
call.respondError(ErrorCode.INVALID_REQUEST, "invalid cursor")
is ChatPageResult.Success ->
call.respond(HttpStatusCode.OK, result.page)
}
}
get("{chat_id}") {
val actor = call.currentUser
val chatId = requireUuid(call.parameters["chat_id"], "chat_id")
val chat = suspendedTransaction {
chatService.findAccessible(actor.id, chatId)
}
if (chat == null) {
call.respondError(ErrorCode.NOT_FOUND, "chat not found")
return@get
}
call.respond(HttpStatusCode.OK, chat)
}
}
}
@@ -0,0 +1,9 @@
package com.mtusi.messenger.main.infrastructure.controllers.chat.requests
import kotlinx.serialization.Serializable
@Serializable
data class CreateChatRequest(
val title: String,
val memberIds: List<String>,
)
@@ -0,0 +1,41 @@
package com.mtusi.messenger.main.infrastructure.controllers.health
import com.mtusi.messenger.main.extensions.respondError
import com.mtusi.messenger.main.infrastructure.controllers.health.responses.HealthResponse
import com.mtusi.messenger.main.infrastructure.types.ErrorCode
import com.mtusi.messenger.main.plugins.suspendedTransaction
import io.ktor.http.HttpStatusCode
import io.ktor.server.application.log
import io.ktor.server.response.respond
import io.ktor.server.routing.Routing
import io.ktor.server.routing.get
import io.ktor.server.routing.route
fun Routing.configureHealthRouting() = route("/health") {
get("live") {
call.respond(HttpStatusCode.OK, HealthResponse())
}
// PostgreSQL is the only dependency of the synchronous path: without it nothing can be served.
get("ready") {
val isDatabaseReachable = try {
suspendedTransaction {
exec("SELECT 1")
}
true
} catch (cause: Exception) {
call.application.log.warn("Readiness check failed: ${cause.message}")
false
}
if (!isDatabaseReachable) {
call.respondError(ErrorCode.UNAVAILABLE, "database unavailable")
return@get
}
call.respond(HttpStatusCode.OK, HealthResponse())
}
}
@@ -0,0 +1,6 @@
package com.mtusi.messenger.main.infrastructure.controllers.health.responses
import kotlinx.serialization.Serializable
@Serializable
data class HealthResponse(val status: String = "ok")
@@ -0,0 +1,88 @@
package com.mtusi.messenger.main.infrastructure.controllers.message
import com.mtusi.messenger.main.extensions.currentUser
import com.mtusi.messenger.main.extensions.respondError
import com.mtusi.messenger.main.infrastructure.controllers._common.parameters.pageParameters
import com.mtusi.messenger.main.infrastructure.controllers.message.requests.CreateMessageRequest
import com.mtusi.messenger.main.infrastructure.models.message.MAX_MESSAGE_TEXT_LENGTH
import com.mtusi.messenger.main.infrastructure.services.message.MessageService
import com.mtusi.messenger.main.infrastructure.services.message.results.MessageCreationResult
import com.mtusi.messenger.main.infrastructure.services.message.results.MessagePageResult
import com.mtusi.messenger.main.infrastructure.types.ErrorCode
import com.mtusi.messenger.main.plugins.authentication.SESSION_AUTH
import com.mtusi.messenger.main.plugins.suspendedTransaction
import com.mtusi.messenger.main.utils.requireNonBlankBounded
import com.mtusi.messenger.main.utils.requireUuid
import io.ktor.http.HttpStatusCode
import io.ktor.server.auth.authenticate
import io.ktor.server.request.receive
import io.ktor.server.response.respond
import io.ktor.server.routing.Routing
import io.ktor.server.routing.get
import io.ktor.server.routing.post
import io.ktor.server.routing.route
import org.koin.ktor.ext.inject
fun Routing.configureMessageRouting() = route("/api/v1/chats/{chat_id}/messages") {
val messageService by inject<MessageService>()
authenticate(SESSION_AUTH) {
post {
val actor = call.currentUser
val chatId = requireUuid(call.parameters["chat_id"], "chat_id")
val body = call.receive<CreateMessageRequest>()
requireNonBlankBounded(
body.text,
min = 1,
max = MAX_MESSAGE_TEXT_LENGTH,
field = "text"
)
val result = suspendedTransaction {
messageService.send(
chatId = chatId,
senderId = actor.id,
text = body.text
)
}
when (result) {
is MessageCreationResult.ChatNotFound ->
call.respondError(ErrorCode.NOT_FOUND, "chat not found")
is MessageCreationResult.Success ->
call.respond(HttpStatusCode.Created, result.message)
}
}
get {
val actor = call.currentUser
val chatId = requireUuid(call.parameters["chat_id"], "chat_id")
val (limit, cursor) = call.pageParameters()
val result = suspendedTransaction {
messageService.findPageByChatId(
chatId = chatId,
actorId = actor.id,
limit = limit,
cursor = cursor
)
}
when (result) {
is MessagePageResult.ChatNotFound ->
call.respondError(ErrorCode.NOT_FOUND, "chat not found")
is MessagePageResult.InvalidCursor ->
call.respondError(ErrorCode.INVALID_REQUEST, "invalid cursor")
is MessagePageResult.Success ->
call.respond(HttpStatusCode.OK, result.page)
}
}
}
}
@@ -0,0 +1,8 @@
package com.mtusi.messenger.main.infrastructure.controllers.message.requests
import kotlinx.serialization.Serializable
@Serializable
data class CreateMessageRequest(
val text: String,
)
@@ -0,0 +1,83 @@
package com.mtusi.messenger.main.infrastructure.controllers.user
import com.mtusi.messenger.main.extensions.currentUser
import com.mtusi.messenger.main.extensions.respondError
import com.mtusi.messenger.main.infrastructure.controllers.user.requests.CreateUserRequest
import com.mtusi.messenger.main.infrastructure.models.user.MAX_DISPLAY_NAME_LENGTH
import com.mtusi.messenger.main.infrastructure.services.user.UserService
import com.mtusi.messenger.main.infrastructure.services.user.results.UserCreationResult
import com.mtusi.messenger.main.infrastructure.types.ErrorCode
import com.mtusi.messenger.main.plugins.authentication.SESSION_AUTH
import com.mtusi.messenger.main.plugins.suspendedTransaction
import com.mtusi.messenger.main.utils.requireNonBlankBounded
import com.mtusi.messenger.main.utils.requireUsername
import io.ktor.http.HttpStatusCode
import io.ktor.server.auth.authenticate
import io.ktor.server.request.receive
import io.ktor.server.response.respond
import io.ktor.server.routing.Routing
import io.ktor.server.routing.get
import io.ktor.server.routing.post
import io.ktor.server.routing.route
import org.koin.ktor.ext.inject
private const val PASSWORD_MIN = 12
private const val PASSWORD_MAX = 128
fun Routing.configureUserRouting() = route("/api/v1/users") {
val userService by inject<UserService>()
post {
val body = call.receive<CreateUserRequest>()
requireUsername(body.username)
requireNonBlankBounded(
body.displayName,
min = 1,
max = MAX_DISPLAY_NAME_LENGTH,
field = "display_name"
)
requireNonBlankBounded(
body.password,
min = PASSWORD_MIN,
max = PASSWORD_MAX,
field = "password"
)
val result = suspendedTransaction {
userService.create(
username = body.username,
displayName = body.displayName,
password = body.password
)
}
when (result) {
is UserCreationResult.UsernameTaken ->
call.respondError(ErrorCode.CONFLICT, "username already taken")
is UserCreationResult.Success ->
call.respond(HttpStatusCode.Created, result.user)
}
}
authenticate(SESSION_AUTH) {
get("me") {
val user = suspendedTransaction {
userService.findById(call.currentUser.id)
}
if (user == null) {
call.respondError(ErrorCode.UNAUTHORIZED, "unknown user")
return@get
}
call.respond(HttpStatusCode.OK, user)
}
}
}
@@ -0,0 +1,10 @@
package com.mtusi.messenger.main.infrastructure.controllers.user.requests
import kotlinx.serialization.Serializable
@Serializable
data class CreateUserRequest(
val username: String,
val displayName: String,
val password: String,
)
@@ -0,0 +1,13 @@
package com.mtusi.messenger.main.infrastructure.dto
import com.mtusi.messenger.main.compat.serializers.SerialUUID
import kotlinx.serialization.Serializable
import kotlin.time.Instant
@Serializable
data class Chat(
val id: SerialUUID,
val title: String,
val memberIds: List<SerialUUID>,
val createdAt: Instant,
)
@@ -0,0 +1,14 @@
package com.mtusi.messenger.main.infrastructure.dto
import com.mtusi.messenger.main.compat.serializers.SerialUUID
import kotlinx.serialization.Serializable
import kotlin.time.Instant
@Serializable
data class Message(
val id: SerialUUID,
val chatId: SerialUUID,
val senderId: SerialUUID,
val text: String,
val createdAt: Instant,
)
@@ -0,0 +1,9 @@
package com.mtusi.messenger.main.infrastructure.dto
import kotlinx.serialization.Serializable
@Serializable
data class PageResponse<T : Any>(
val items: List<T>,
val nextCursor: String?,
)
@@ -0,0 +1,13 @@
package com.mtusi.messenger.main.infrastructure.dto
import com.mtusi.messenger.main.compat.serializers.SerialUUID
import kotlinx.serialization.Serializable
import kotlin.time.Instant
@Serializable
data class User(
val id: SerialUUID,
val username: String,
val displayName: String,
val createdAt: Instant,
)
@@ -0,0 +1,6 @@
package com.mtusi.messenger.main.infrastructure.dto.authentication
data class IssuedSession(
val session: Session,
val token: String,
)
@@ -0,0 +1,12 @@
package com.mtusi.messenger.main.infrastructure.dto.authentication
import java.util.UUID
import kotlin.time.Instant
data class Session(
val id: UUID,
val userId: UUID,
val tokenHash: String,
val createdAt: Instant,
val expiresAt: Instant,
)
@@ -0,0 +1,8 @@
package com.mtusi.messenger.main.infrastructure.dto.authentication
import kotlin.time.Instant
data class SessionRevocation(
val tokenHash: String,
val expiresAt: Instant,
)
@@ -0,0 +1,8 @@
package com.mtusi.messenger.main.infrastructure.dto.authentication
import com.mtusi.messenger.main.infrastructure.dto.User
data class UserCredentials(
val user: User,
val passwordHash: String,
)
@@ -0,0 +1,17 @@
package com.mtusi.messenger.main.infrastructure.models.authentication
import com.mtusi.messenger.main.infrastructure.models.user.UserModel
import org.jetbrains.exposed.v1.core.ReferenceOption
import org.jetbrains.exposed.v1.core.dao.id.java.UUIDTable
import org.jetbrains.exposed.v1.datetime.timestamp
object SessionModel : UUIDTable("sessions") {
val userId = reference("user_id", UserModel, onDelete = ReferenceOption.CASCADE, onUpdate = ReferenceOption.NO_ACTION, fkName = "sessions_user_id_fkey")
val tokenHash = varchar("token_hash", 64).uniqueIndex("sessions_token_hash_key")
val createdAt = timestamp("created_at")
val expiresAt = timestamp("expires_at")
init {
index("sessions_user_id_idx", false, userId)
}
}
@@ -0,0 +1,11 @@
package com.mtusi.messenger.main.infrastructure.models.authentication
import org.jetbrains.exposed.v1.core.Table
import org.jetbrains.exposed.v1.datetime.timestamp
object SessionRevocationModel : Table("session_revocations") {
val tokenHash = varchar("token_hash", 64)
val expiresAt = timestamp("expires_at")
override val primaryKey = PrimaryKey(tokenHash, name = "session_revocations_pkey")
}
@@ -0,0 +1,17 @@
package com.mtusi.messenger.main.infrastructure.models.chat
import com.mtusi.messenger.main.infrastructure.models.user.UserModel
import org.jetbrains.exposed.v1.core.ReferenceOption
import org.jetbrains.exposed.v1.core.Table
object ChatMemberModel : Table("chat_members") {
val chatId = reference("chat_id", ChatModel, onDelete = ReferenceOption.CASCADE, onUpdate = ReferenceOption.NO_ACTION, fkName = "chat_members_chat_id_fkey")
val userId = reference("user_id", UserModel, onDelete = ReferenceOption.CASCADE, onUpdate = ReferenceOption.NO_ACTION, fkName = "chat_members_user_id_fkey")
val position = integer("position")
override val primaryKey = PrimaryKey(chatId, userId)
init {
index("chat_members_user_id_idx", false, userId)
}
}
@@ -0,0 +1,12 @@
package com.mtusi.messenger.main.infrastructure.models.chat
import org.jetbrains.exposed.v1.core.dao.id.java.UUIDTable
import org.jetbrains.exposed.v1.datetime.timestamp
const val MAX_CHAT_TITLE_LENGTH = 100
const val MAX_CHAT_MEMBERS = 100
object ChatModel : UUIDTable("chats") {
val title = varchar("title", MAX_CHAT_TITLE_LENGTH)
val createdAt = timestamp("created_at")
}
@@ -0,0 +1,20 @@
package com.mtusi.messenger.main.infrastructure.models.message
import com.mtusi.messenger.main.infrastructure.models.chat.ChatModel
import com.mtusi.messenger.main.infrastructure.models.user.UserModel
import org.jetbrains.exposed.v1.core.ReferenceOption
import org.jetbrains.exposed.v1.core.dao.id.java.UUIDTable
import org.jetbrains.exposed.v1.datetime.timestamp
const val MAX_MESSAGE_TEXT_LENGTH = 4000
object MessageModel : UUIDTable("messages") {
val chatId = reference("chat_id", ChatModel, onDelete = ReferenceOption.CASCADE, onUpdate = ReferenceOption.NO_ACTION, fkName = "messages_chat_id_fkey")
val senderId = reference("sender_id", UserModel, onDelete = ReferenceOption.CASCADE, onUpdate = ReferenceOption.NO_ACTION, fkName = "messages_sender_id_fkey")
val text = varchar("text", MAX_MESSAGE_TEXT_LENGTH)
val createdAt = timestamp("created_at")
init {
index("messages_chat_id_created_at_id_idx", false, chatId, createdAt, id)
}
}
@@ -0,0 +1,14 @@
package com.mtusi.messenger.main.infrastructure.models.user
import org.jetbrains.exposed.v1.core.dao.id.java.UUIDTable
import org.jetbrains.exposed.v1.datetime.timestamp
const val MAX_USERNAME_LENGTH = 32
const val MAX_DISPLAY_NAME_LENGTH = 100
object UserModel : UUIDTable("users") {
val username = varchar("username", MAX_USERNAME_LENGTH).uniqueIndex("users_username_key")
val displayName = varchar("display_name", MAX_DISPLAY_NAME_LENGTH)
val passwordHash = varchar("password_hash", 255)
val createdAt = timestamp("created_at")
}
@@ -0,0 +1,8 @@
package com.mtusi.messenger.main.infrastructure.repositories
import org.koin.core.annotation.ComponentScan
import org.koin.core.annotation.Module
@Module
@ComponentScan
class RepositoriesModule
@@ -0,0 +1,3 @@
package com.mtusi.messenger.main.infrastructure.repositories
interface Repository<TId, TEntity>
@@ -0,0 +1,88 @@
package com.mtusi.messenger.main.infrastructure.repositories._common
import com.mtusi.messenger.main.config.redis.RedisConfig
import com.mtusi.messenger.main.utils.resolveSecret
import io.lettuce.core.ClientOptions
import io.lettuce.core.RedisClient
import io.lettuce.core.RedisConnectionException
import io.lettuce.core.RedisURI
import io.lettuce.core.SocketOptions
import io.lettuce.core.TimeoutOptions
import io.lettuce.core.api.StatefulRedisConnection
import io.lettuce.core.api.async.RedisAsyncCommands
import io.lettuce.core.codec.StringCodec
import kotlinx.coroutines.future.await
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import org.koin.core.annotation.Single
import java.time.Duration
import kotlin.time.Duration.Companion.seconds
import kotlin.time.TimeSource
private val RECONNECT_BACKOFF = 1.seconds
/**
* Lazily connected Redis client. The application must start and serve requests without Redis, so the connection
* is opened on first use, a failed attempt is not retried for [RECONNECT_BACKOFF], and commands issued while
* disconnected fail immediately instead of queueing behind the reconnect.
*/
@Single
class RedisConnection(
config: RedisConfig
) : AutoCloseable {
private val uri = RedisURI.builder()
.withHost(config.host)
.withPort(config.port)
.withTimeout(Duration.ofMillis(config.commandTimeoutMs))
.apply {
val password = resolveSecret(config.password, config.passwordFile)
if (password != null) {
if (config.username != null) withAuthentication(config.username, password) else withPassword(password.toCharArray())
}
}
.build()
private val client = RedisClient.create().apply {
options = ClientOptions.builder()
.autoReconnect(true)
.disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS)
.timeoutOptions(TimeoutOptions.enabled(Duration.ofMillis(config.commandTimeoutMs)))
.socketOptions(SocketOptions.builder().connectTimeout(Duration.ofMillis(config.connectTimeoutMs)).build())
.build()
}
private val mutex = Mutex()
@Volatile
private var connection: StatefulRedisConnection<String, String>? = null
@Volatile
private var nextAttempt = TimeSource.Monotonic.markNow()
suspend fun commands(): RedisAsyncCommands<String, String> {
return (connection ?: connect()).async()
}
private suspend fun connect(): StatefulRedisConnection<String, String> = mutex.withLock {
connection?.let { return it }
if (nextAttempt.hasNotPassedNow()) {
throw RedisConnectionException("Redis is unavailable, next connection attempt is postponed")
}
return try {
client.connectAsync(StringCodec.UTF8, uri).await().also { connection = it }
} catch (e: Exception) {
nextAttempt = TimeSource.Monotonic.markNow() + RECONNECT_BACKOFF
throw e as? RedisConnectionException ?: RedisConnectionException("Unable to connect to Redis", e)
}
}
override fun close() {
connection?.close()
client.shutdown()
}
}
@@ -0,0 +1,73 @@
package com.mtusi.messenger.main.infrastructure.repositories.authentication.session
import com.mtusi.messenger.main.infrastructure.dto.authentication.Session
import com.mtusi.messenger.main.infrastructure.models.authentication.SessionModel
import com.mtusi.messenger.main.utils.nowMicros
import org.jetbrains.exposed.v1.core.ResultRow
import org.jetbrains.exposed.v1.core.and
import org.jetbrains.exposed.v1.core.eq
import org.jetbrains.exposed.v1.core.greater
import org.jetbrains.exposed.v1.jdbc.deleteWhere
import org.jetbrains.exposed.v1.jdbc.insert
import org.jetbrains.exposed.v1.jdbc.selectAll
import org.koin.core.annotation.Single
import java.util.UUID
import kotlin.time.Clock
import kotlin.time.Duration
import kotlin.time.Instant
@Single
class ExposedSessionRepository : SessionRepository {
override fun create(
userId: UUID,
tokenHash: String,
ttl: Duration
): Session {
val createdAt = Clock.System.nowMicros()
val expiresAt = createdAt + ttl
val insertedRow = SessionModel.insert {
it[this.userId] = userId
it[this.tokenHash] = tokenHash
it[this.createdAt] = createdAt
it[this.expiresAt] = expiresAt
}
return Session(
id = insertedRow[SessionModel.id].value,
userId = userId,
tokenHash = tokenHash,
createdAt = createdAt,
expiresAt = expiresAt
)
}
override fun findActiveByTokenHash(
tokenHash: String,
now: Instant
): Session? {
return SessionModel
.selectAll()
.where((SessionModel.tokenHash eq tokenHash) and (SessionModel.expiresAt greater now))
.firstOrNull()
?.toSession()
}
override fun deleteById(
id: UUID
): Boolean {
val deletedRows = SessionModel.deleteWhere { SessionModel.id eq id }
return deletedRows > 0
}
private fun ResultRow.toSession() = Session(
id = this[SessionModel.id].value,
userId = this[SessionModel.userId].value,
tokenHash = this[SessionModel.tokenHash],
createdAt = this[SessionModel.createdAt],
expiresAt = this[SessionModel.expiresAt]
)
}
@@ -0,0 +1,26 @@
package com.mtusi.messenger.main.infrastructure.repositories.authentication.session
import com.mtusi.messenger.main.infrastructure.dto.authentication.Session
import com.mtusi.messenger.main.infrastructure.repositories.Repository
import java.util.UUID
import kotlin.time.Duration
import kotlin.time.Instant
interface SessionRepository : Repository<UUID, Session> {
fun create(
userId: UUID,
tokenHash: String,
ttl: Duration
): Session
fun findActiveByTokenHash(
tokenHash: String,
now: Instant
): Session?
fun deleteById(
id: UUID
): Boolean
}
@@ -0,0 +1,11 @@
package com.mtusi.messenger.main.infrastructure.repositories.authentication.session.cache
import com.mtusi.messenger.main.infrastructure.dto.authentication.Session
sealed class CachedSession {
data class Active(val session: Session) : CachedSession()
data object Revoked : CachedSession()
}
@@ -0,0 +1,87 @@
package com.mtusi.messenger.main.infrastructure.repositories.authentication.session.cache
import com.mtusi.messenger.main.compat.serializers.SerialUUID
import com.mtusi.messenger.main.infrastructure.dto.authentication.Session
import com.mtusi.messenger.main.infrastructure.repositories._common.RedisConnection
import io.lettuce.core.SetArgs
import kotlinx.coroutines.future.await
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import org.koin.core.annotation.Single
import kotlin.time.Instant
private const val KEY_PREFIX = "session:"
private const val REVOKED = "revoked"
@Single
class RedisSessionCacheRepository(
private val redis: RedisConnection
) : SessionCacheRepository {
override suspend fun find(
tokenHash: String
): CachedSession? {
val value = redis.commands().get(key(tokenHash)).await() ?: return null
if (value == REVOKED) {
return CachedSession.Revoked
}
return CachedSession.Active(
Json.decodeFromString<SessionEntry>(value).toSession(tokenHash)
)
}
override suspend fun putIfAbsent(
session: Session,
cachedUntil: Instant
) {
redis.commands().set(
key(session.tokenHash),
Json.encodeToString(SessionEntry.from(session)),
SetArgs.Builder.nx().pxAt(cachedUntil.toEpochMilliseconds())
).await()
}
override suspend fun revoke(
tokenHash: String,
expiresAt: Instant
) {
redis.commands().set(
key(tokenHash),
REVOKED,
SetArgs.Builder.pxAt(expiresAt.toEpochMilliseconds())
).await()
}
private fun key(tokenHash: String) = KEY_PREFIX + tokenHash
@Serializable
private data class SessionEntry(
val id: SerialUUID,
val userId: SerialUUID,
val createdAt: Instant,
val expiresAt: Instant
) {
fun toSession(tokenHash: String) = Session(
id = id,
userId = userId,
tokenHash = tokenHash,
createdAt = createdAt,
expiresAt = expiresAt
)
companion object {
fun from(session: Session) = SessionEntry(
id = session.id,
userId = session.userId,
createdAt = session.createdAt,
expiresAt = session.expiresAt
)
}
}
}
@@ -0,0 +1,34 @@
package com.mtusi.messenger.main.infrastructure.repositories.authentication.session.cache
import com.mtusi.messenger.main.infrastructure.dto.authentication.Session
import com.mtusi.messenger.main.infrastructure.repositories.Repository
import kotlin.time.Instant
/**
* Cache-aside copy of [com.mtusi.messenger.main.infrastructure.repositories.authentication.session.SessionRepository].
* PostgreSQL stays the source of truth: losing every key only costs a database lookup.
*/
interface SessionCacheRepository : Repository<String, Session> {
suspend fun find(
tokenHash: String
): CachedSession?
/**
* Stores the session until [cachedUntil] unless the key already exists, so a lookup racing with a logout
* cannot overwrite the tombstone written by [revoke].
*/
suspend fun putIfAbsent(
session: Session,
cachedUntil: Instant
)
/**
* Replaces the entry with a tombstone that lives until [expiresAt], when the session would have expired.
*/
suspend fun revoke(
tokenHash: String,
expiresAt: Instant
)
}
@@ -0,0 +1,52 @@
package com.mtusi.messenger.main.infrastructure.repositories.authentication.session.revocation
import com.mtusi.messenger.main.infrastructure.dto.authentication.SessionRevocation
import com.mtusi.messenger.main.infrastructure.models.authentication.SessionRevocationModel
import org.jetbrains.exposed.v1.core.eq
import org.jetbrains.exposed.v1.core.greater
import org.jetbrains.exposed.v1.core.lessEq
import org.jetbrains.exposed.v1.jdbc.deleteWhere
import org.jetbrains.exposed.v1.jdbc.insertIgnore
import org.jetbrains.exposed.v1.jdbc.selectAll
import org.koin.core.annotation.Single
import kotlin.time.Instant
@Single
class ExposedSessionRevocationRepository : SessionRevocationRepository {
override fun add(
revocation: SessionRevocation
) {
SessionRevocationModel.insertIgnore {
it[tokenHash] = revocation.tokenHash
it[expiresAt] = revocation.expiresAt
}
}
override fun findPending(
now: Instant
): List<SessionRevocation> {
return SessionRevocationModel
.selectAll()
.where(SessionRevocationModel.expiresAt greater now)
.map {
SessionRevocation(
tokenHash = it[SessionRevocationModel.tokenHash],
expiresAt = it[SessionRevocationModel.expiresAt]
)
}
}
override fun delete(
tokenHash: String
) {
SessionRevocationModel.deleteWhere { SessionRevocationModel.tokenHash eq tokenHash }
}
override fun deleteExpired(
now: Instant
) {
SessionRevocationModel.deleteWhere { SessionRevocationModel.expiresAt lessEq now }
}
}
@@ -0,0 +1,31 @@
package com.mtusi.messenger.main.infrastructure.repositories.authentication.session.revocation
import com.mtusi.messenger.main.infrastructure.dto.authentication.SessionRevocation
import com.mtusi.messenger.main.infrastructure.repositories.Repository
import kotlin.time.Instant
/**
* Logouts that still have to be written to the session cache as tombstones (outbox).
*/
interface SessionRevocationRepository : Repository<String, SessionRevocation> {
fun add(
revocation: SessionRevocation
)
/**
* Revocations of sessions that have not expired yet: an expired session is rejected even if its copy is cached.
*/
fun findPending(
now: Instant
): List<SessionRevocation>
fun delete(
tokenHash: String
)
fun deleteExpired(
now: Instant
)
}
@@ -0,0 +1,33 @@
package com.mtusi.messenger.main.infrastructure.repositories.chat
import com.mtusi.messenger.main.infrastructure.dto.Chat
import com.mtusi.messenger.main.infrastructure.repositories.Repository
import com.mtusi.messenger.main.utils.PageKey
import java.util.UUID
interface ChatRepository : Repository<UUID, Chat> {
fun create(
title: String,
memberIds: List<UUID>
): Chat
fun findById(
id: UUID
): Chat?
fun isMember(
chatId: UUID,
userId: UUID
): Boolean
/**
* Chats of [userId] ordered by `(created_at, id)`, strictly after [after].
*/
fun findPageByMemberId(
userId: UUID,
after: PageKey?,
limit: Int
): List<Chat>
}
@@ -0,0 +1,134 @@
package com.mtusi.messenger.main.infrastructure.repositories.chat
import com.mtusi.messenger.main.infrastructure.dto.Chat
import com.mtusi.messenger.main.infrastructure.models.chat.ChatMemberModel
import com.mtusi.messenger.main.infrastructure.models.chat.ChatModel
import com.mtusi.messenger.main.utils.PageKey
import com.mtusi.messenger.main.utils.exposed.operations.RowGreater
import com.mtusi.messenger.main.utils.nowMicros
import org.jetbrains.exposed.v1.core.QueryParameter
import org.jetbrains.exposed.v1.core.ResultRow
import org.jetbrains.exposed.v1.core.SortOrder
import org.jetbrains.exposed.v1.core.and
import org.jetbrains.exposed.v1.core.dao.id.EntityID
import org.jetbrains.exposed.v1.core.eq
import org.jetbrains.exposed.v1.core.inList
import org.jetbrains.exposed.v1.jdbc.batchInsert
import org.jetbrains.exposed.v1.jdbc.insert
import org.jetbrains.exposed.v1.jdbc.selectAll
import org.koin.core.annotation.Single
import java.util.UUID
import kotlin.time.Clock
@Single
class ExposedChatRepository : ChatRepository {
override fun create(
title: String,
memberIds: List<UUID>
): Chat {
val insertedRow = ChatModel.insert {
it[this.title] = title
it[this.createdAt] = Clock.System.nowMicros()
}
val chatId = insertedRow[ChatModel.id].value
ChatMemberModel.batchInsert(memberIds.withIndex()) { (position, userId) ->
this[ChatMemberModel.chatId] = chatId
this[ChatMemberModel.userId] = userId
this[ChatMemberModel.position] = position
}
return Chat(
id = chatId,
title = title,
memberIds = memberIds,
createdAt = insertedRow[ChatModel.createdAt]
)
}
override fun findById(
id: UUID
): Chat? {
val row = ChatModel
.selectAll()
.where(ChatModel.id eq id)
.firstOrNull()
?: return null
return row.toChat(findMemberIds(listOf(id))[id].orEmpty())
}
override fun isMember(
chatId: UUID,
userId: UUID
): Boolean {
return ChatMemberModel
.selectAll()
.where((ChatMemberModel.chatId eq chatId) and (ChatMemberModel.userId eq userId))
.empty()
.not()
}
override fun findPageByMemberId(
userId: UUID,
after: PageKey?,
limit: Int
): List<Chat> {
var condition = ChatMemberModel.userId eq userId
if (after != null) {
condition = condition and RowGreater(
left = listOf(ChatModel.createdAt, ChatModel.id),
right = listOf(
QueryParameter(after.createdAt, ChatModel.createdAt.columnType),
QueryParameter(EntityID(after.id, ChatModel), ChatModel.id.columnType)
)
)
}
val rows = ChatModel
.innerJoin(ChatMemberModel)
.selectAll()
.where(condition)
.orderBy(ChatModel.createdAt to SortOrder.ASC, ChatModel.id to SortOrder.ASC)
.limit(limit)
.toList()
val memberIds = findMemberIds(rows.map { it[ChatModel.id].value })
return rows.map {
it.toChat(memberIds[it[ChatModel.id].value].orEmpty())
}
}
private fun findMemberIds(
chatIds: List<UUID>
): Map<UUID, List<UUID>> {
if (chatIds.isEmpty()) {
return emptyMap()
}
return ChatMemberModel
.selectAll()
.where(ChatMemberModel.chatId inList chatIds)
.orderBy(ChatMemberModel.position to SortOrder.ASC)
.groupBy(
keySelector = { it[ChatMemberModel.chatId].value },
valueTransform = { it[ChatMemberModel.userId].value }
)
}
private fun ResultRow.toChat(memberIds: List<UUID>) = Chat(
id = this[ChatModel.id].value,
title = this[ChatModel.title],
memberIds = memberIds,
createdAt = this[ChatModel.createdAt]
)
}
@@ -0,0 +1,81 @@
package com.mtusi.messenger.main.infrastructure.repositories.message
import com.mtusi.messenger.main.infrastructure.dto.Message
import com.mtusi.messenger.main.infrastructure.models.message.MessageModel
import com.mtusi.messenger.main.utils.PageKey
import com.mtusi.messenger.main.utils.exposed.operations.RowGreater
import com.mtusi.messenger.main.utils.nowMicros
import org.jetbrains.exposed.v1.core.QueryParameter
import org.jetbrains.exposed.v1.core.ResultRow
import org.jetbrains.exposed.v1.core.SortOrder
import org.jetbrains.exposed.v1.core.and
import org.jetbrains.exposed.v1.core.dao.id.EntityID
import org.jetbrains.exposed.v1.core.eq
import org.jetbrains.exposed.v1.jdbc.insert
import org.jetbrains.exposed.v1.jdbc.selectAll
import org.koin.core.annotation.Single
import java.util.UUID
import kotlin.time.Clock
@Single
class ExposedMessageRepository : MessageRepository {
override fun create(
chatId: UUID,
senderId: UUID,
text: String
): Message {
val insertedRow = MessageModel.insert {
it[this.chatId] = chatId
it[this.senderId] = senderId
it[this.text] = text
it[this.createdAt] = Clock.System.nowMicros()
}
return Message(
id = insertedRow[MessageModel.id].value,
chatId = chatId,
senderId = senderId,
text = text,
createdAt = insertedRow[MessageModel.createdAt]
)
}
override fun findPageByChatId(
chatId: UUID,
after: PageKey?,
limit: Int
): List<Message> {
var condition = MessageModel.chatId eq chatId
if (after != null) {
condition = condition and RowGreater(
left = listOf(MessageModel.createdAt, MessageModel.id),
right = listOf(
QueryParameter(after.createdAt, MessageModel.createdAt.columnType),
QueryParameter(EntityID(after.id, MessageModel), MessageModel.id.columnType)
)
)
}
return MessageModel
.selectAll()
.where(condition)
.orderBy(MessageModel.createdAt to SortOrder.ASC, MessageModel.id to SortOrder.ASC)
.limit(limit)
.map {
it.toMessage()
}
}
private fun ResultRow.toMessage() = Message(
id = this[MessageModel.id].value,
chatId = this[MessageModel.chatId].value,
senderId = this[MessageModel.senderId].value,
text = this[MessageModel.text],
createdAt = this[MessageModel.createdAt]
)
}
@@ -0,0 +1,22 @@
package com.mtusi.messenger.main.infrastructure.repositories.message
import com.mtusi.messenger.main.infrastructure.dto.Message
import com.mtusi.messenger.main.infrastructure.repositories.Repository
import com.mtusi.messenger.main.utils.PageKey
import java.util.UUID
interface MessageRepository : Repository<UUID, Message> {
fun create(
chatId: UUID,
senderId: UUID,
text: String
): Message
fun findPageByChatId(
chatId: UUID,
after: PageKey?,
limit: Int
): List<Message>
}
@@ -0,0 +1,82 @@
package com.mtusi.messenger.main.infrastructure.repositories.user
import com.mtusi.messenger.main.infrastructure.dto.User
import com.mtusi.messenger.main.infrastructure.dto.authentication.UserCredentials
import com.mtusi.messenger.main.infrastructure.models.user.UserModel
import com.mtusi.messenger.main.utils.nowMicros
import org.jetbrains.exposed.v1.core.ResultRow
import org.jetbrains.exposed.v1.core.eq
import org.jetbrains.exposed.v1.core.inList
import org.jetbrains.exposed.v1.jdbc.insertIgnore
import org.jetbrains.exposed.v1.jdbc.selectAll
import org.koin.core.annotation.Single
import java.util.UUID
import kotlin.time.Clock
@Single
class ExposedUserRepository : UserRepository {
override fun create(
username: String,
displayName: String,
passwordHash: String
): User? {
val statement = UserModel.insertIgnore {
it[this.username] = username
it[this.displayName] = displayName
it[this.passwordHash] = passwordHash
it[this.createdAt] = Clock.System.nowMicros()
}
if (statement.insertedCount == 0) {
return null
}
return statement.resultedValues
?.singleOrNull()
?.toUser()
}
override fun findById(
id: UUID
): User? {
return UserModel
.selectAll()
.where(UserModel.id eq id)
.firstOrNull()
?.toUser()
}
override fun findCredentialsByUsername(
username: String
): UserCredentials? {
return UserModel
.selectAll()
.where(UserModel.username eq username)
.firstOrNull()
?.let {
UserCredentials(
user = it.toUser(),
passwordHash = it[UserModel.passwordHash]
)
}
}
override fun countByIds(
ids: Collection<UUID>
): Long {
return UserModel
.selectAll()
.where(UserModel.id inList ids)
.count()
}
private fun ResultRow.toUser() = User(
id = this[UserModel.id].value,
username = this[UserModel.username],
displayName = this[UserModel.displayName],
createdAt = this[UserModel.createdAt]
)
}
@@ -0,0 +1,28 @@
package com.mtusi.messenger.main.infrastructure.repositories.user
import com.mtusi.messenger.main.infrastructure.dto.User
import com.mtusi.messenger.main.infrastructure.dto.authentication.UserCredentials
import com.mtusi.messenger.main.infrastructure.repositories.Repository
import java.util.UUID
interface UserRepository : Repository<UUID, User> {
fun create(
username: String,
displayName: String,
passwordHash: String
): User?
fun findById(
id: UUID
): User?
fun findCredentialsByUsername(
username: String
): UserCredentials?
fun countByIds(
ids: Collection<UUID>
): Long
}
@@ -0,0 +1,8 @@
package com.mtusi.messenger.main.infrastructure.services
import org.koin.core.annotation.ComponentScan
import org.koin.core.annotation.Module
@Module
@ComponentScan
class ServicesModule
@@ -0,0 +1,34 @@
package com.mtusi.messenger.main.infrastructure.services.authentication
import com.mtusi.messenger.main.infrastructure.dto.User
import com.mtusi.messenger.main.infrastructure.dto.authentication.IssuedSession
import com.mtusi.messenger.main.infrastructure.dto.authentication.Session
import java.util.UUID
interface AuthenticationService {
fun validateCredentials(
username: String,
password: String
): User?
fun createSession(
userId: UUID
): IssuedSession
/**
* Opens its own transaction only on a cache miss, so it must not be called inside one.
*/
suspend fun findSessionByToken(
token: String
): Session?
/**
* Deletes the session in PostgreSQL, then replaces its cached copy with a tombstone. Without Redis only the
* database is updated: a copy cached before the outage can then live for at most the cache TTL.
*/
suspend fun revokeSession(
session: Session
): Boolean
}
@@ -0,0 +1,311 @@
package com.mtusi.messenger.main.infrastructure.services.authentication
import com.mtusi.messenger.main.config.authentication.AuthenticationConfig
import com.mtusi.messenger.main.infrastructure.dto.User
import com.mtusi.messenger.main.infrastructure.dto.authentication.IssuedSession
import com.mtusi.messenger.main.infrastructure.dto.authentication.Session
import com.mtusi.messenger.main.infrastructure.dto.authentication.SessionRevocation
import com.mtusi.messenger.main.infrastructure.repositories.authentication.session.SessionRepository
import com.mtusi.messenger.main.infrastructure.repositories.authentication.session.cache.CachedSession
import com.mtusi.messenger.main.infrastructure.repositories.authentication.session.cache.SessionCacheRepository
import com.mtusi.messenger.main.infrastructure.repositories.authentication.session.revocation.SessionRevocationRepository
import com.mtusi.messenger.main.infrastructure.repositories.user.UserRepository
import com.mtusi.messenger.main.infrastructure.services.hashing.HashingService
import com.mtusi.messenger.main.infrastructure.services.hashing.types.HashingAlgorithm
import com.mtusi.messenger.main.plugins.suspendedTransaction
import com.mtusi.messenger.main.utils.computeSha256
import io.lettuce.core.RedisException
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.CompletableDeferred
import kotlinx.coroutines.NonCancellable
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.withContext
import org.koin.core.annotation.Single
import org.slf4j.LoggerFactory
import java.io.IOException
import java.security.SecureRandom
import java.util.Base64
import java.util.UUID
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicLong
import kotlin.time.Clock
import kotlin.time.Instant
import kotlin.time.Duration.Companion.seconds
import kotlin.time.TimeSource
private const val TOKEN_BYTES = 32
private val CACHE_RESTORE_BACKOFF = 1.seconds
@Single
class DefaultAuthenticationService(
private val userRepository: UserRepository,
private val sessionRepository: SessionRepository,
private val sessionCacheRepository: SessionCacheRepository,
private val sessionRevocationRepository: SessionRevocationRepository,
private val hashingService: HashingService,
private val config: AuthenticationConfig
) : AuthenticationService {
private val logger = LoggerFactory.getLogger(DefaultAuthenticationService::class.java)
private val random = SecureRandom()
/**
* Database lookups currently running per token hash. Concurrent cache misses for one token wait for the
* lookup already in flight instead of each sending their own query (cache stampede protection).
*/
private val inFlightLookups = ConcurrentHashMap<String, CompletableDeferred<Session?>>()
/**
* Only availability changes are logged: with Redis down every request would otherwise add a warning.
*/
private val isCacheAvailable = AtomicBoolean(true)
/**
* Number of failed cache operations. A failure may have lost a logout tombstone, so the cache is trusted only
* after the pending revocations were written to it with no failure since: [trustedAtFailures] equals this counter.
* A fresh process starts untrusted, as the previous one may have stopped with revocations still pending.
*/
private val cacheFailures = AtomicLong()
@Volatile
private var trustedAtFailures = -1L
private val cacheRestoreMutex = Mutex()
@Volatile
private var nextCacheRestoreAttempt = TimeSource.Monotonic.markNow()
private val dummyPasswordHash by lazy {
hashingService.computeHash(HashingAlgorithm.Argon2id, "dummy-password-for-timing")
}
override fun validateCredentials(
username: String,
password: String
): User? {
val credentials = userRepository.findCredentialsByUsername(username)
val isPasswordValid = hashingService.validateHash(
algorithm = HashingAlgorithm.Argon2id,
input = password,
hashed = credentials?.passwordHash ?: dummyPasswordHash
)
if (credentials == null || !isPasswordValid) {
return null
}
return credentials.user
}
override fun createSession(
userId: UUID
): IssuedSession {
val token = ByteArray(TOKEN_BYTES)
.also(random::nextBytes)
.let(Base64.getUrlEncoder().withoutPadding()::encodeToString)
val session = sessionRepository.create(
userId = userId,
tokenHash = token.toByteArray().computeSha256(),
ttl = config.sessionTtlSeconds.seconds
)
return IssuedSession(
session = session,
token = token
)
}
override suspend fun findSessionByToken(
token: String
): Session? {
val tokenHash = token.toByteArray().computeSha256()
val now = Clock.System.now()
when (val cached = findCachedSession(tokenHash)) {
is CachedSession.Revoked -> return null
is CachedSession.Active -> return cached.session.takeIf { it.expiresAt > now }
null -> Unit
}
if (!config.sessionCacheSingleFlight) {
return selectSession(tokenHash, now)?.also { cacheSession(it, now) }
}
val flight = CompletableDeferred<Session?>()
inFlightLookups.putIfAbsent(tokenHash, flight)?.let { leader ->
return leader.await()
}
try {
// The query is shared with the followers, so the leader's own cancellation must not abort it.
val session = withContext(NonCancellable) {
selectSession(tokenHash, now)
}
flight.complete(session)
// Requests arriving until the cache write lands reuse this result instead of starting a new lookup.
// A logout drops the flight first (see revokeSession), so a revoked session is never handed out here.
session?.let { cacheSession(it, now) }
return session
} catch (e: Throwable) {
flight.completeExceptionally(e)
throw e
} finally {
inFlightLookups.remove(tokenHash, flight)
}
}
private suspend fun selectSession(
tokenHash: String,
now: Instant
): Session? {
return suspendedTransaction {
sessionRepository.findActiveByTokenHash(tokenHash, now)
}
}
override suspend fun revokeSession(
session: Session
): Boolean {
// The revocation is kept in PostgreSQL until its tombstone is in Redis: if Redis is unavailable now,
// the tombstone is written when the cache is trusted again (see restoreCache), even after a restart.
val isDeleted = suspendedTransaction {
sessionRevocationRepository.add(SessionRevocation(session.tokenHash, session.expiresAt))
sessionRepository.deleteById(session.id)
}
// A lookup that started before the delete must not be joined by requests arriving after the logout.
inFlightLookups.remove(session.tokenHash)
if (withCache { sessionCacheRepository.revoke(session.tokenHash, session.expiresAt) } != null) {
// Best effort: a leftover row only costs one more tombstone write on the next restore.
runCatchingDatabase { sessionRevocationRepository.delete(session.tokenHash) }
}
return isDeleted
}
private suspend fun findCachedSession(
tokenHash: String
): CachedSession? {
if (trustedAtFailures != cacheFailures.get() && !restoreCache()) {
return null
}
return withCache { sessionCacheRepository.find(tokenHash) }
}
/**
* Writes the tombstones of logouts that happened while Redis was unavailable. Until that succeeds the cache
* is bypassed: a copy cached before the outage could otherwise outlive the logout. One request restores,
* the others go to the database meanwhile; a failed attempt is repeated after [CACHE_RESTORE_BACKOFF].
*/
private suspend fun restoreCache(): Boolean {
if (!cacheRestoreMutex.tryLock()) {
return false
}
try {
val failures = cacheFailures.get()
if (trustedAtFailures == failures) {
return true
}
if (nextCacheRestoreAttempt.hasNotPassedNow()) {
return false
}
nextCacheRestoreAttempt = TimeSource.Monotonic.markNow() + CACHE_RESTORE_BACKOFF
val now = Clock.System.now()
val pending = runCatchingDatabase {
sessionRevocationRepository.deleteExpired(now)
sessionRevocationRepository.findPending(now)
} ?: return false
for (revocation in pending) {
withCache { sessionCacheRepository.revoke(revocation.tokenHash, revocation.expiresAt) } ?: return false
}
if (pending.isNotEmpty()) {
runCatchingDatabase { pending.forEach { sessionRevocationRepository.delete(it.tokenHash) } }
logger.info("Wrote ${pending.size} pending session revocations to the cache")
}
// A failure while restoring changed the counter, so the cache stays untrusted.
trustedAtFailures = failures
return trustedAtFailures == cacheFailures.get()
} finally {
cacheRestoreMutex.unlock()
}
}
private suspend fun <T> runCatchingDatabase(
statement: () -> T
): T? {
return try {
suspendedTransaction { statement() }
} catch (e: CancellationException) {
throw e
} catch (e: Exception) {
logger.warn("Unable to update pending session revocations: ${e.message}")
null
}
}
private suspend fun cacheSession(
session: Session,
now: Instant
) {
withCache {
sessionCacheRepository.putIfAbsent(
session = session,
cachedUntil = minOf(session.expiresAt, now + config.sessionCacheTtlSeconds.seconds)
)
}
}
/**
* Runs a cache operation, treating an unavailable Redis as a miss: the database stays the source of truth.
* A command already written when Redis drops the connection fails with the raw [IOException] (connection
* reset), not with a [RedisException]; it means the same.
*/
private suspend fun <T> withCache(
operation: suspend () -> T
): T? {
return try {
operation().also {
if (isCacheAvailable.compareAndSet(false, true)) {
logger.info("Session cache is available again")
}
}
} catch (e: RedisException) {
onCacheUnavailable(e)
} catch (e: IOException) {
onCacheUnavailable(e)
}
}
private fun onCacheUnavailable(
cause: Exception
): Nothing? {
cacheFailures.incrementAndGet()
if (isCacheAvailable.compareAndSet(true, false)) {
logger.warn("Session cache is unavailable, sessions are read from the database: ${cause.message}")
}
return null
}
}
@@ -0,0 +1,27 @@
package com.mtusi.messenger.main.infrastructure.services.chat
import com.mtusi.messenger.main.infrastructure.dto.Chat
import com.mtusi.messenger.main.infrastructure.services.chat.results.ChatCreationResult
import com.mtusi.messenger.main.infrastructure.services.chat.results.ChatPageResult
import java.util.UUID
interface ChatService {
fun create(
creatorId: UUID,
title: String,
memberIds: List<UUID>
): ChatCreationResult
fun findAccessible(
userId: UUID,
chatId: UUID
): Chat?
fun findPageAccessible(
userId: UUID,
limit: Int,
cursor: String?
): ChatPageResult
}
@@ -0,0 +1,79 @@
package com.mtusi.messenger.main.infrastructure.services.chat
import com.mtusi.messenger.main.infrastructure.dto.Chat
import com.mtusi.messenger.main.infrastructure.repositories.chat.ChatRepository
import com.mtusi.messenger.main.infrastructure.repositories.user.UserRepository
import com.mtusi.messenger.main.infrastructure.services.chat.results.ChatCreationResult
import com.mtusi.messenger.main.infrastructure.services.chat.results.ChatPageResult
import com.mtusi.messenger.main.utils.PageKey
import com.mtusi.messenger.main.utils.decodeCursor
import com.mtusi.messenger.main.utils.toPage
import org.koin.core.annotation.Single
import java.util.UUID
@Single
class DefaultChatService(
private val chatRepository: ChatRepository,
private val userRepository: UserRepository
) : ChatService {
override fun create(
creatorId: UUID,
title: String,
memberIds: List<UUID>
): ChatCreationResult {
if (memberIds.toSet().size != memberIds.size) {
return ChatCreationResult.DuplicateMembers
}
if (creatorId !in memberIds) {
return ChatCreationResult.CreatorNotMember
}
if (userRepository.countByIds(memberIds) != memberIds.size.toLong()) {
return ChatCreationResult.UnknownMembers
}
val chat = chatRepository.create(
title = title,
memberIds = memberIds
)
return ChatCreationResult.Success(chat)
}
override fun findAccessible(
userId: UUID,
chatId: UUID
): Chat? {
return chatRepository.findById(chatId)
?.takeIf { userId in it.memberIds }
}
override fun findPageAccessible(
userId: UUID,
limit: Int,
cursor: String?
): ChatPageResult {
val scope = "chats:$userId"
val after = cursor?.let {
decodeCursor(it, scope) ?: return ChatPageResult.InvalidCursor
}
val page = chatRepository
.findPageByMemberId(
userId = userId,
after = after,
limit = limit + 1
)
.toPage(limit, scope) {
PageKey(it.createdAt, it.id)
}
return ChatPageResult.Success(page)
}
}
@@ -0,0 +1,17 @@
package com.mtusi.messenger.main.infrastructure.services.chat.results
import com.mtusi.messenger.main.infrastructure.dto.Chat
sealed class ChatCreationResult {
sealed class Error : ChatCreationResult()
data object DuplicateMembers : Error()
data object CreatorNotMember : Error()
data object UnknownMembers : Error()
data class Success(
val chat: Chat
) : ChatCreationResult()
}
@@ -0,0 +1,16 @@
package com.mtusi.messenger.main.infrastructure.services.chat.results
import com.mtusi.messenger.main.infrastructure.dto.Chat
import com.mtusi.messenger.main.infrastructure.dto.PageResponse
sealed class ChatPageResult {
sealed class Error : ChatPageResult()
data object InvalidCursor : Error()
data class Success(
val page: PageResponse<Chat>
) : ChatPageResult()
}
@@ -0,0 +1,123 @@
package com.mtusi.messenger.main.infrastructure.services.hashing
import com.mtusi.messenger.main.infrastructure.services.hashing.types.HashingAlgorithm
import org.bouncycastle.crypto.generators.Argon2BytesGenerator
import org.bouncycastle.crypto.params.Argon2Parameters
import org.koin.core.annotation.Single
import java.security.MessageDigest
import java.security.SecureRandom
import java.util.Base64
// TODO: Move to config later
private const val ARGON2_MEMORY_KIB = 19 * 1024
private const val ARGON2_ITERATIONS = 2
private const val ARGON2_PARALLELISM = 1
private const val ARGON2_SALT_LENGTH = 16
private const val ARGON2_HASH_LENGTH = 32
@Single
class DefaultHashingService : HashingService {
private val random = SecureRandom()
private val encoder = Base64.getEncoder().withoutPadding()
private val decoder = Base64.getDecoder()
override fun computeHash(
algorithm: HashingAlgorithm,
input: String
): String {
return when (algorithm) {
HashingAlgorithm.Argon2id -> computeHashArgon2id(input)
}
}
private fun computeHashArgon2id(input: String): String {
val salt = ByteArray(ARGON2_SALT_LENGTH).also(random::nextBytes)
val hash = argon2id(
input = input,
salt = salt,
memoryKib = ARGON2_MEMORY_KIB,
iterations = ARGON2_ITERATIONS,
parallelism = ARGON2_PARALLELISM,
length = ARGON2_HASH_LENGTH
)
return "\$argon2id\$v=19\$m=$ARGON2_MEMORY_KIB,t=$ARGON2_ITERATIONS,p=$ARGON2_PARALLELISM" +
"\$${encoder.encodeToString(salt)}\$${encoder.encodeToString(hash)}"
}
override fun validateHash(
algorithm: HashingAlgorithm,
input: String,
hashed: String
): Boolean {
return when (algorithm) {
HashingAlgorithm.Argon2id -> validateHashArgon2id(input, hashed)
}
}
private fun validateHashArgon2id(
input: String,
hashed: String
): Boolean {
return try {
val parts = hashed.split('$')
if (parts.size != 6 || parts[1] != "argon2id" || parts[2] != "v=19") {
return false
}
val parameters = parts[3]
.split(',')
.associate {
val (key, value) = it.split('=')
key to value.toInt()
}
val salt = decoder.decode(parts[4])
val expected = decoder.decode(parts[5])
val actual = argon2id(
input = input,
salt = salt,
memoryKib = parameters.getValue("m"),
iterations = parameters.getValue("t"),
parallelism = parameters.getValue("p"),
length = expected.size
)
MessageDigest.isEqual(expected, actual)
} catch (_: Exception) {
false
}
}
private fun argon2id(
input: String,
salt: ByteArray,
memoryKib: Int,
iterations: Int,
parallelism: Int,
length: Int
): ByteArray {
val parameters = Argon2Parameters.Builder(Argon2Parameters.ARGON2_id)
.withVersion(Argon2Parameters.ARGON2_VERSION_13)
.withMemoryAsKB(memoryKib)
.withIterations(iterations)
.withParallelism(parallelism)
.withSalt(salt)
.build()
val generator = Argon2BytesGenerator().apply {
init(parameters)
}
return ByteArray(length).also {
generator.generateBytes(input.toByteArray(Charsets.UTF_8), it)
}
}
}
@@ -0,0 +1,18 @@
package com.mtusi.messenger.main.infrastructure.services.hashing
import com.mtusi.messenger.main.infrastructure.services.hashing.types.HashingAlgorithm
interface HashingService {
fun computeHash(
algorithm: HashingAlgorithm,
input: String
): String
fun validateHash(
algorithm: HashingAlgorithm,
input: String,
hashed: String
): Boolean
}
@@ -0,0 +1,5 @@
package com.mtusi.messenger.main.infrastructure.services.hashing.types
sealed class HashingAlgorithm {
data object Argon2id : HashingAlgorithm()
}
@@ -0,0 +1,68 @@
package com.mtusi.messenger.main.infrastructure.services.message
import com.mtusi.messenger.main.infrastructure.repositories.chat.ChatRepository
import com.mtusi.messenger.main.infrastructure.repositories.message.MessageRepository
import com.mtusi.messenger.main.infrastructure.services.message.results.MessageCreationResult
import com.mtusi.messenger.main.infrastructure.services.message.results.MessagePageResult
import com.mtusi.messenger.main.utils.PageKey
import com.mtusi.messenger.main.utils.decodeCursor
import com.mtusi.messenger.main.utils.toPage
import org.koin.core.annotation.Single
import java.util.UUID
@Single
class DefaultMessageService(
private val chatRepository: ChatRepository,
private val messageRepository: MessageRepository
) : MessageService {
override fun send(
chatId: UUID,
senderId: UUID,
text: String
): MessageCreationResult {
if (!chatRepository.isMember(chatId, senderId)) {
return MessageCreationResult.ChatNotFound
}
val message = messageRepository.create(
chatId = chatId,
senderId = senderId,
text = text
)
return MessageCreationResult.Success(message)
}
override fun findPageByChatId(
chatId: UUID,
actorId: UUID,
limit: Int,
cursor: String?
): MessagePageResult {
if (!chatRepository.isMember(chatId, actorId)) {
return MessagePageResult.ChatNotFound
}
val scope = "messages:$chatId"
val after = cursor?.let {
decodeCursor(it, scope) ?: return MessagePageResult.InvalidCursor
}
val page = messageRepository
.findPageByChatId(
chatId = chatId,
after = after,
limit = limit + 1
)
.toPage(limit, scope) {
PageKey(it.createdAt, it.id)
}
return MessagePageResult.Success(page)
}
}
@@ -0,0 +1,22 @@
package com.mtusi.messenger.main.infrastructure.services.message
import com.mtusi.messenger.main.infrastructure.services.message.results.MessageCreationResult
import com.mtusi.messenger.main.infrastructure.services.message.results.MessagePageResult
import java.util.UUID
interface MessageService {
fun send(
chatId: UUID,
senderId: UUID,
text: String
): MessageCreationResult
fun findPageByChatId(
chatId: UUID,
actorId: UUID,
limit: Int,
cursor: String?
): MessagePageResult
}
@@ -0,0 +1,15 @@
package com.mtusi.messenger.main.infrastructure.services.message.results
import com.mtusi.messenger.main.infrastructure.dto.Message
sealed class MessageCreationResult {
sealed class Error : MessageCreationResult()
data object ChatNotFound : Error()
data class Success(
val message: Message
) : MessageCreationResult()
}
@@ -0,0 +1,17 @@
package com.mtusi.messenger.main.infrastructure.services.message.results
import com.mtusi.messenger.main.infrastructure.dto.Message
import com.mtusi.messenger.main.infrastructure.dto.PageResponse
sealed class MessagePageResult {
sealed class Error : MessagePageResult()
data object ChatNotFound : Error()
data object InvalidCursor : Error()
data class Success(
val page: PageResponse<Message>
) : MessagePageResult()
}
@@ -0,0 +1,43 @@
package com.mtusi.messenger.main.infrastructure.services.user
import com.mtusi.messenger.main.infrastructure.dto.User
import com.mtusi.messenger.main.infrastructure.repositories.user.UserRepository
import com.mtusi.messenger.main.infrastructure.services.hashing.HashingService
import com.mtusi.messenger.main.infrastructure.services.hashing.types.HashingAlgorithm
import com.mtusi.messenger.main.infrastructure.services.user.results.UserCreationResult
import org.koin.core.annotation.Single
import java.util.UUID
@Single
class DefaultUserService(
private val userRepository: UserRepository,
private val hashingService: HashingService
) : UserService {
override fun create(
username: String,
displayName: String,
password: String
): UserCreationResult {
val passwordHash = hashingService.computeHash(
algorithm = HashingAlgorithm.Argon2id,
input = password
)
val user = userRepository.create(
username = username,
displayName = displayName,
passwordHash = passwordHash
) ?: return UserCreationResult.UsernameTaken
return UserCreationResult.Success(user)
}
override fun findById(
id: UUID
): User? {
return userRepository.findById(id)
}
}
@@ -0,0 +1,19 @@
package com.mtusi.messenger.main.infrastructure.services.user
import com.mtusi.messenger.main.infrastructure.dto.User
import com.mtusi.messenger.main.infrastructure.services.user.results.UserCreationResult
import java.util.UUID
interface UserService {
fun create(
username: String,
displayName: String,
password: String
): UserCreationResult
fun findById(
id: UUID
): User?
}
@@ -0,0 +1,15 @@
package com.mtusi.messenger.main.infrastructure.services.user.results
import com.mtusi.messenger.main.infrastructure.dto.User
sealed class UserCreationResult {
sealed class Error : UserCreationResult()
data object UsernameTaken : Error()
data class Success(
val user: User
) : UserCreationResult()
}
@@ -0,0 +1,3 @@
package com.mtusi.messenger.main.infrastructure.types
class ApiException(val code: ErrorCode, message: String) : RuntimeException(message)
@@ -0,0 +1,6 @@
package com.mtusi.messenger.main.infrastructure.types
object AuthChallenge {
const val BASIC = "Basic realm=\"messenger\", charset=\"UTF-8\""
const val BEARER = "Bearer realm=\"messenger\""
}
@@ -0,0 +1,15 @@
package com.mtusi.messenger.main.infrastructure.types
import io.ktor.http.HttpStatusCode
enum class ErrorCode(val wire: String, val status: HttpStatusCode) {
INVALID_REQUEST("invalid_request", HttpStatusCode.BadRequest),
UNAUTHORIZED("unauthorized", HttpStatusCode.Unauthorized),
NOT_FOUND("not_found", HttpStatusCode.NotFound),
CONFLICT("conflict", HttpStatusCode.Conflict),
PAYLOAD_TOO_LARGE("payload_too_large", HttpStatusCode.PayloadTooLarge),
UNSUPPORTED_MEDIA_TYPE("unsupported_media_type", HttpStatusCode.UnsupportedMediaType),
RATE_LIMITED("rate_limited", HttpStatusCode.TooManyRequests),
UNAVAILABLE("unavailable", HttpStatusCode.ServiceUnavailable),
INTERNAL_ERROR("internal_error", HttpStatusCode.InternalServerError),
}
@@ -0,0 +1,14 @@
package com.mtusi.messenger.main.plugins
import io.ktor.server.application.Application
import io.ktor.server.application.install
import io.ktor.server.plugins.calllogging.CallLogging
import org.slf4j.event.Level
fun Application.configureCallLogging() = install(CallLogging) {
level = Level.INFO
filter { call ->
val uri = call.request.local.uri
uri.startsWith("/api") || uri.startsWith("/health")
}
}
@@ -0,0 +1,21 @@
package com.mtusi.messenger.main.plugins
import io.ktor.serialization.kotlinx.json.json
import io.ktor.server.application.Application
import io.ktor.server.application.install
import io.ktor.server.plugins.contentnegotiation.ContentNegotiation
import kotlinx.serialization.ExperimentalSerializationApi
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonNamingStrategy
@OptIn(ExperimentalSerializationApi::class)
val json = Json {
ignoreUnknownKeys = false
explicitNulls = true
encodeDefaults = true
namingStrategy = JsonNamingStrategy.SnakeCase
}
fun Application.configureContentNegotiation() = install(ContentNegotiation) {
json(json)
}
@@ -0,0 +1,149 @@
package com.mtusi.messenger.main.plugins
import com.mtusi.messenger.main.config.database.DatabaseConfig
import com.mtusi.messenger.main.config.database.SerialDatabaseConfig
import com.mtusi.messenger.main.infrastructure.models.authentication.SessionModel
import com.mtusi.messenger.main.infrastructure.models.authentication.SessionRevocationModel
import com.mtusi.messenger.main.infrastructure.models.chat.ChatMemberModel
import com.mtusi.messenger.main.infrastructure.models.chat.ChatModel
import com.mtusi.messenger.main.infrastructure.models.message.MessageModel
import com.mtusi.messenger.main.infrastructure.models.user.UserModel
import com.mtusi.messenger.main.utils.resolveSecret
import com.typesafe.config.ConfigFactory
import com.zaxxer.hikari.HikariConfig
import com.zaxxer.hikari.HikariDataSource
import io.ktor.server.application.Application
import io.ktor.server.application.ApplicationStopped
import io.ktor.server.config.HoconApplicationConfig
import io.ktor.server.config.getAs
import kotlinx.coroutines.Dispatchers
import org.flywaydb.core.Flyway
import org.jetbrains.exposed.v1.core.ExperimentalDatabaseMigrationApi
import org.jetbrains.exposed.v1.core.Table
import org.jetbrains.exposed.v1.core.DatabaseConfig as ExposedDatabaseConfig
import org.jetbrains.exposed.v1.jdbc.Database
import org.jetbrains.exposed.v1.jdbc.JdbcTransaction
import org.jetbrains.exposed.v1.jdbc.transactions.experimental.newSuspendedTransaction
import org.jetbrains.exposed.v1.jdbc.transactions.transaction
import org.jetbrains.exposed.v1.migration.jdbc.MigrationUtils
import org.koin.ktor.ext.inject
import java.io.File
import javax.sql.DataSource
private const val MIGRATIONS_DIRECTORY = "src/main/resources/migrations"
private const val DEVELOPMENT_DATABASE_CONFIG = "run/development/config/database.conf"
private const val VALIDATION_TIMEOUT_MS = 1000L
fun Application.configureDatabase() {
val config by inject<DatabaseConfig>()
val dataSource = config.createDataSource()
Database.connect(
datasource = dataSource,
databaseConfig = ExposedDatabaseConfig {
defaultMaxAttempts = 1
}
)
applyDatabaseMigrations(dataSource)
monitor.subscribe(ApplicationStopped) {
dataSource.close()
}
}
private fun DatabaseConfig.createDataSource(): HikariDataSource {
return HikariDataSource(
HikariConfig().apply {
poolName = "messenger"
jdbcUrl = jdbcConnectionUrl
username = this@createDataSource.username
password = resolveSecret(this@createDataSource.password, passwordFile).orEmpty()
maximumPoolSize = maxPoolSize
connectionTimeout = connectionTimeoutMs
validationTimeout = minOf(VALIDATION_TIMEOUT_MS, connectionTimeoutMs - 1)
addDataSourceProperty("options", "-c statement_timeout=$statementTimeoutMs")
}
)
}
fun applyDatabaseMigrations(
dataSource: DataSource
) {
val flyway = Flyway.configure()
.dataSource(dataSource)
.locations("classpath:migrations")
.load()
flyway.migrate()
flyway.validate()
}
fun main(args: Array<out String>) {
generateMigration(args.joinToString("_"))
}
@OptIn(ExperimentalDatabaseMigrationApi::class)
private fun generateMigration(description: String) {
require(description.isNotEmpty()) { "Description cannot be empty" }
val tables: Array<Table> = arrayOf(
UserModel,
ChatModel,
ChatMemberModel,
MessageModel,
SessionModel,
SessionRevocationModel
)
val config = HoconApplicationConfig(ConfigFactory.parseFile(File(DEVELOPMENT_DATABASE_CONFIG)).resolve())
.property("database")
.getAs<SerialDatabaseConfig>()
config.createDataSource().use { dataSource ->
Database.connect(dataSource)
applyDatabaseMigrations(dataSource)
val migrations = File(MIGRATIONS_DIRECTORY).listFiles { it.extension == "sql" }.orEmpty()
val latestVersion = migrations.maxOfOrNull {
it.name
.substringBefore("__")
.drop(1)
.toInt()
}
val version = latestVersion?.inc() ?: 1
transaction {
val statements = MigrationUtils.statementsRequiredForDatabaseMigration(*tables)
if (statements.isEmpty()) {
println("Database schema is up to date, no migration generated")
return@transaction
}
val script = MigrationUtils.generateMigrationScript(
tables = tables,
scriptDirectory = MIGRATIONS_DIRECTORY,
scriptName = "V${version}__$description"
)
println("Generated migration ${script.path}")
}
}
}
suspend fun <R> suspendedTransaction(statement: JdbcTransaction.() -> R) = newSuspendedTransaction(
context = Dispatchers.IO,
statement = statement
)
@@ -0,0 +1,7 @@
package com.mtusi.messenger.main.plugins
import io.ktor.server.application.Application
import io.ktor.server.application.install
import io.ktor.server.plugins.defaultheaders.DefaultHeaders
fun Application.configureDefaultHeaders() = install(DefaultHeaders)
@@ -0,0 +1,27 @@
package com.mtusi.messenger.main.plugins
import com.mtusi.messenger.main.config.ConfigModule
import com.mtusi.messenger.main.infrastructure.repositories.RepositoriesModule
import com.mtusi.messenger.main.infrastructure.services.ServicesModule
import io.ktor.server.application.Application
import io.ktor.server.application.install
import org.koin.dsl.module
import org.koin.ksp.generated.module
import org.koin.ktor.plugin.Koin
fun Application.configureKoin() {
val applicationModule = module {
single { this@configureKoin }
}
install(Koin) {
modules(
applicationModule,
ConfigModule().module,
RepositoriesModule().module,
ServicesModule().module
)
}
}
@@ -0,0 +1,16 @@
package com.mtusi.messenger.main.plugins
import com.mtusi.messenger.main.infrastructure.repositories._common.RedisConnection
import io.ktor.server.application.Application
import io.ktor.server.application.ApplicationStopped
import org.koin.ktor.ext.get
fun Application.configureRedis() {
val redisConnection = get<RedisConnection>()
monitor.subscribe(ApplicationStopped) {
redisConnection.close()
}
}

Some files were not shown because too many files have changed in this diff Show More