forked from mtusi2026/mtusi2026lab3
Move lab2 to lab3
This commit is contained in:
@@ -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
|
||||
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -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:
|
||||
@@ -0,0 +1 @@
|
||||
kotlin.code.style=official
|
||||
@@ -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" }
|
||||
Vendored
BIN
Binary file not shown.
+7
@@ -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
|
||||
@@ -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
@@ -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
|
||||
@@ -0,0 +1,12 @@
|
||||
ktor {
|
||||
|
||||
application {
|
||||
modules = [com.mtusi.messenger.main.AppKt.module]
|
||||
}
|
||||
|
||||
deployment {
|
||||
host = "127.0.0.1"
|
||||
port = 8080
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
authentication {
|
||||
realm = "messenger"
|
||||
sessionTtlSeconds = 3600
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
database {
|
||||
host = "localhost"
|
||||
port = 5432
|
||||
name = "messenger"
|
||||
username = "username"
|
||||
password = "password"
|
||||
maxPoolSize = 10
|
||||
connectionTimeoutMs = 2000
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
redis {
|
||||
host = "localhost"
|
||||
port = 6379
|
||||
connectTimeoutMs = 500
|
||||
commandTimeoutMs = 500
|
||||
}
|
||||
Executable
+10
@@ -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
|
||||
Executable
+19
@@ -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
|
||||
Executable
+7
@@ -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
|
||||
@@ -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;
|
||||
@@ -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
|
||||
+10
@@ -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
|
||||
|
||||
}
|
||||
+11
@@ -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>()
|
||||
+11
@@ -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>()!!
|
||||
+31
@@ -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)
|
||||
}
|
||||
+53
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
+13
@@ -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,
|
||||
)
|
||||
+112
@@ -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)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
+9
@@ -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>,
|
||||
)
|
||||
+41
@@ -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())
|
||||
}
|
||||
|
||||
}
|
||||
+6
@@ -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")
|
||||
+88
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
+8
@@ -0,0 +1,8 @@
|
||||
package com.mtusi.messenger.main.infrastructure.controllers.message.requests
|
||||
|
||||
import kotlinx.serialization.Serializable
|
||||
|
||||
@Serializable
|
||||
data class CreateMessageRequest(
|
||||
val text: String,
|
||||
)
|
||||
+83
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
+10
@@ -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,
|
||||
)
|
||||
+6
@@ -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,
|
||||
)
|
||||
+8
@@ -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,
|
||||
)
|
||||
+8
@@ -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,
|
||||
)
|
||||
+17
@@ -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)
|
||||
}
|
||||
}
|
||||
+11
@@ -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")
|
||||
}
|
||||
+17
@@ -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")
|
||||
}
|
||||
+20
@@ -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")
|
||||
}
|
||||
+8
@@ -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>
|
||||
+88
@@ -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()
|
||||
}
|
||||
|
||||
}
|
||||
+73
@@ -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]
|
||||
)
|
||||
|
||||
}
|
||||
+26
@@ -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
|
||||
|
||||
}
|
||||
+11
@@ -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()
|
||||
|
||||
}
|
||||
+87
@@ -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
|
||||
)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
+34
@@ -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
|
||||
)
|
||||
|
||||
}
|
||||
+52
@@ -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 }
|
||||
}
|
||||
|
||||
}
|
||||
+31
@@ -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
|
||||
)
|
||||
|
||||
}
|
||||
+33
@@ -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>
|
||||
|
||||
}
|
||||
+134
@@ -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]
|
||||
)
|
||||
|
||||
}
|
||||
+81
@@ -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]
|
||||
)
|
||||
|
||||
}
|
||||
+22
@@ -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>
|
||||
|
||||
}
|
||||
+82
@@ -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]
|
||||
)
|
||||
|
||||
}
|
||||
+28
@@ -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
|
||||
+34
@@ -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
|
||||
|
||||
}
|
||||
+311
@@ -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
|
||||
|
||||
}
|
||||
+79
@@ -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)
|
||||
}
|
||||
|
||||
}
|
||||
+17
@@ -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()
|
||||
|
||||
}
|
||||
+16
@@ -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()
|
||||
|
||||
}
|
||||
+123
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
+18
@@ -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
|
||||
|
||||
}
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
package com.mtusi.messenger.main.infrastructure.services.hashing.types
|
||||
|
||||
sealed class HashingAlgorithm {
|
||||
data object Argon2id : HashingAlgorithm()
|
||||
}
|
||||
+68
@@ -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)
|
||||
}
|
||||
|
||||
}
|
||||
+22
@@ -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
|
||||
|
||||
}
|
||||
+15
@@ -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()
|
||||
|
||||
}
|
||||
+17
@@ -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()
|
||||
|
||||
}
|
||||
+43
@@ -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?
|
||||
|
||||
}
|
||||
+15
@@ -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
Reference in New Issue
Block a user