ci: bump version with Build-134

fix(tournament): use Optional[String] for selfUrl ConfigProperty to avoid startup failure
Empty string config value caused DeploymentException when injected as String. Optional[String] handles absent/empty cleanly without defaultValue workaround. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-21 20:12:06 +00:00 · 2026-06-21 21:50:00 +02:00 · 2026-06-21 21:47:05 +02:00 · 2026-06-21 21:37:29 +02:00 · 2026-06-21 21:33:57 +02:00 · 2026-06-21 21:24:21 +02:00
21 changed files with 405 additions and 126 deletions
@@ -65,3 +65,19 @@
 ### Bug Fixes

 * **analytics:** upgrade Spark to 4.0.3 — 3.5.x has no official Docker image ([46af115](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/46af1154de34a8596cb6cb28c6fad7aba90f597c))
+##  (2026-06-21)
+
+### Features
+
+* **analytics:** add 7 new Spark analytics jobs and extend GameSource ([8e17c14](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8e17c14dff740cd115011dfbf17de35083b8fe46))
+* **analytics:** add Dockerfile, CI workflow, and stable jar name for K8s deployment ([95215b6](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/95215b6a420fd526df1aa395f9b087556c8ad03b))
+* **analytics:** add PostgreSQL JDBC write-back to all four batch jobs ([0e0ea4c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/0e0ea4c9893c6efed52e633e55d05ab3ed004502))
+* **analytics:** add Spark batch analytics module ([259b3bb](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/259b3bbb24c0f23326269b93f4b3c84012f727cd))
+* **analytics:** add Structured Streaming, MLlib clustering, GraphX jobs ([e1d80b9](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e1d80b9331666feea191b1fd08aa762f3581c918))
+* **analytics:** always write results to PostgreSQL regardless of input source ([da0e6d1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/da0e6d1ee2d391ecb6291396f82471eb51b1b25e))
+* **official-bots:** park expert bot on tournament server at startup ([#76](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/76)) ([751a58b](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/751a58b6061f7434115e229a7661894c76768bc2))
+
+### Bug Fixes
+
+* **analytics:** upgrade Spark to 4.0.3 — 3.5.x has no official Docker image ([46af115](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/46af1154de34a8596cb6cb28c6fad7aba90f597c))
+* **analytics:** write decompressed PGN to shared PVC path for executor access ([a268a9a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a268a9acb7ba190c76e996ccf3ea3bd00e5cec92))
@@ -145,31 +145,42 @@ object GameSource:
      )
      .filter((F.col("white_id") =!= "").and(F.col("black_id") =!= ""))

-  /** Turns an http(s)/ftp URL into a cluster-local path by fetching it once with SparkContext.addFile, which
-    * distributes the file to every executor. `.zst` is decompressed in-process and the plain `.pgn` is redistributed.
+  /** Turns an http(s)/ftp URL into a path readable by all executors.
+    *
+    * Downloads the file once on the driver, decompresses `.zst` if needed, then writes the result to
+    * `NOWCHESS_PGN_CACHE_DIR` (default `/tmp`). That directory must be on a filesystem shared between the driver pod
+    * and all executor pods — in the k8s deployment this is the `spark-analytics-output` PVC mounted at
+    * `/spark-output`, so set `NOWCHESS_PGN_CACHE_DIR=/spark-output/.pgn-cache`.
+    *
+    * Skips download if the destination file already exists (cache-friendly for repeated runs).
    * Non-URL paths are returned unchanged.
    */
  private def resolvePath(spark: SparkSession, path: String): String =
    if !path.matches("^(https?|ftp)://.*") then path
    else
-      spark.sparkContext.addFile(path)
-      val local = SparkFiles.get(baseName(path))
-      if !local.endsWith(".zst") then "file://" + local
-      else distribute(spark, decompressZstd(local))
+      val cacheDir = sys.env.getOrElse("NOWCHESS_PGN_CACHE_DIR", "/tmp")
+      val destName = baseName(path).stripSuffix(".zst")
+      val destPath = s"$cacheDir/$destName"
+      if !java.io.File(destPath).exists() then
+        spark.sparkContext.addFile(path)
+        val downloaded = SparkFiles.get(baseName(path))
+        if downloaded.endsWith(".zst") then decompressZstd(downloaded, destPath)
+        else
+          java.io.File(destPath).getParentFile.mkdirs()
+          java.nio.file.Files.copy(
+            java.nio.file.Paths.get(downloaded),
+            java.io.File(destPath).toPath,
+            java.nio.file.StandardCopyOption.REPLACE_EXISTING,
+          )
+      "file://" + destPath

  private def baseName(path: String): String = path.substring(path.lastIndexOf('/') + 1)

-  private def distribute(spark: SparkSession, localPath: String): String =
-    spark.sparkContext.addFile("file://" + localPath)
-    "file://" + SparkFiles.get(baseName(localPath))
-
-  /** Decompresses a `.zst` file to a temp `.pgn` using zstd-jni (bundled with Spark at runtime). */
-  private def decompressZstd(srcPath: String): String =
-    val out = java.io.File.createTempFile("lichess-", ".pgn")
-    out.deleteOnExit()
+  /** Decompresses a `.zst` file to `destPath` using zstd-jni (bundled with Spark at runtime). */
+  private def decompressZstd(srcPath: String, destPath: String): Unit =
+    java.io.File(destPath).getParentFile.mkdirs()
    val in = com.github.luben.zstd.ZstdInputStream(
      java.io.BufferedInputStream(java.io.FileInputStream(srcPath)),
    )
-    try java.nio.file.Files.copy(in, out.toPath, java.nio.file.StandardCopyOption.REPLACE_EXISTING)
+    try java.nio.file.Files.copy(in, java.io.File(destPath).toPath, java.nio.file.StandardCopyOption.REPLACE_EXISTING)
    finally in.close()
-    out.getAbsolutePath
@@ -1,3 +1,3 @@
 MAJOR=0
-MINOR=6
+MINOR=7
 PATCH=0
@@ -401,3 +401,37 @@
 ### Reverts

 * Revert "refactor: update metrics paths formatting in application.yml for clarity" ([3870566](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/38705663498d5f47c40dafe2f26198589ede8656))
+##  (2026-06-21)
+
+### Features
+
+* add initialization metrics for various services ([d438e97](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/d438e97f32bdde0bfc63c1b4a8cc810cdd093166))
+* add OpenTelemetry trace configuration with parentbased sampler ([3904d5a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3904d5ad8ad4930ddee65287a7bfab785a6148f5))
+* **analytics:** add Spark batch analytics module ([#70](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/70)) ([39f1657](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/39f1657e1db6e84889af338c43be8cb5c03c3ec3))
+* **config:** update application.yml for PostgreSQL and remove staging/production configurations ([2404e61](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/2404e6164c3b50ffccbea5238d636060d6abe4d6))
+* **config:** update application.yml for staging and production environments ([6113432](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/6113432a14c476a3a0dfc0d449e17d023697f2ba))
+* configure logging and add OpenTelemetry support ([#49](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/49)) ([d57c488](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/d57c4886612d1d92da0e1b79209fc83e6ef537a1))
+* **docker:** add .dockerignore and .gitignore files for build exclusions ([c987d8e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c987d8e258c0e6c4cfbdaa8381c64c410d7a2b83))
+* **docker:** add Dockerfiles for building Quarkus application in native and JVM modes ([3f2d2bb](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3f2d2bb4c97fa8cddba66e1da4427c54236dfeed))
+* **docker:** add Dockerfiles for Quarkus application in JVM and native modes ([34b9933](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/34b993304670cf2aa62cd2f6460cee7b9864b08e))
+* **events:** migrate game-creation and bot flows to Redis Streams NCS-89 ([#62](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/62)) ([a24924c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a24924c23057db3d700a75dbc4333557789cd991))
+* NCS-78 Add Traceability to the Applications ([#46](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/46)) ([649566e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/649566eb3fcf38f91c8896a739f74ea318af312d))
+* NCS-78 Add Traceability to the Applications ([#47](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/47)) ([87dfc6c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/87dfc6c2bcce7f7d58fc641bd8d468a2e584c108))
+* NCS-82 add Swiss-system tournament module ([#55](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/55)) ([c5661de](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c5661de4a0ebf4b33211f5a391840dcf744656b7))
+* **official-bots:** consume GameOver stream for bot cleanup ([#67](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/67)) ([db9d153](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/db9d1533912f4b41c4d1ca80ccffdde5d23d6ff6))
+* **official-bots:** park expert bot on tournament server at startup ([#75](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/75)) ([30295a4](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/30295a4bb95855ee8261c92278bb9ebc80ee12ee))
+* **tournament:** federate tournaments across clusters with DB replication ([5b000a6](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/5b000a6e5f04ea6770d1c7ab6bfdaded77a99172))
+* **tournament:** seed external server registry from env var on startup ([845dc9c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/845dc9c2935c8bc1be42541dfaf31c9a861d3272))
+* true-microservices ([#40](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/40)) ([5909242](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/590924254e8a2754de661a57a03e43f89ceb6299))
+
+### Bug Fixes
+
+* enable official bots to connect to external tournament server ([#71](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/71)) ([688d30e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/688d30e2b10026923372be5fca3c63eaaee2de2a))
+* **official-bots:** configure JWT verification ([#72](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/72)) ([98c64fc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/98c64fc0d56dc542beb31c75f4b9056d91de03cd))
+* **official-bots:** correct parkOn path from /api/bots to /api/account/bots ([1be9949](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1be9949c0b5c6a1db535696620d77735050d6c93))
+* **official-bots:** make botToken optional, fall back to env, fix 502 status ([f43d193](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f43d1930d80670d810c57b54eaa3789854fa082c))
+* **official-bots:** NCS-70-auto-register official bots with account service ([#59](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/59)) ([7117a93](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7117a93376272094d0b1a6abf2121254ce396684))
+
+### Reverts
+
+* Revert "refactor: update metrics paths formatting in application.yml for clarity" ([3870566](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/38705663498d5f47c40dafe2f26198589ede8656))
@@ -26,6 +26,8 @@ nowchess:
    prefix: nowchess
  internal:
    secret: 123abc
+  tournament:
+    service-url: http://localhost:8088

 "%deployed":
  quarkus:
@@ -49,3 +51,5 @@ nowchess:
      prefix: ${REDIS_PREFIX:nowchess}
    internal:
      secret: ${INTERNAL_SECRET}
+    tournament:
+      service-url: ${TOURNAMENT_SERVICE_URL:http://localhost:8088}
@@ -25,15 +25,13 @@ class TournamentJoinResource:
  @POST
  @Path("/join-tournament")
  def joinTournament(req: JoinTournamentRequest): Response =
-    val serverUrl  = req.serverUrl.filter(_.nonEmpty).getOrElse(player.defaultServerUrl)
    val difficulty = if req.difficulty.nonEmpty then req.difficulty else "medium"
    log.infof(
-      "Official bot join requested — tournament=%s difficulty=%s server=%s",
+      "Official bot join requested — tournament=%s difficulty=%s",
      req.tournamentId,
      difficulty,
-      serverUrl,
    )
-    player.joinTournament(req.tournamentId, req.botToken, difficulty, serverUrl) match
+    player.joinTournament(req.tournamentId, req.botToken, difficulty) match
      case Right(botId) =>
        val resp = JoinTournamentResponse(botId, difficulty, "joining")
        Response.ok(resp).build()
@@ -20,7 +20,7 @@ object TournamentBotConfig:
      tournamentId <- env.get("TOURNAMENT_ID").filter(_.nonEmpty)
      token        <- env.get("TOURNAMENT_BOT_TOKEN").filter(_.nonEmpty)
      botId        <- jwtSubject(token)
-      serverUrl  = env.getOrElse("TOURNAMENT_SERVER_URL", "http://141.37.123.132:8086")
+      serverUrl  = env.getOrElse("TOURNAMENT_SERVICE_URL", "http://localhost:8086")
      difficulty = env.getOrElse("TOURNAMENT_BOT_DIFFICULTY", "medium")
    yield TournamentBotConfig(serverUrl, tournamentId, token, botId, difficulty)

@@ -38,8 +38,8 @@ class TournamentBotGamePlayer:
  @volatile private var running = true
  // scalafix:on DisableSyntax.var

-  val defaultServerUrl: String =
-    System.getenv().asScala.getOrElse("TOURNAMENT_SERVER_URL", "http://141.37.123.132:8086")
+  val tournamentServiceUrl: String =
+    System.getenv().asScala.getOrElse("TOURNAMENT_SERVICE_URL", "http://localhost:8086")

  @PostConstruct
  def initialize(): Unit =
@@ -52,31 +52,41 @@ class TournamentBotGamePlayer:
        startAsync(cfg)

  private def parkOnStartup(): Unit =
-    park(defaultServerUrl, "expert") match
-      case Some(id) => log.infof("Parked expert bot on %s as id %s", defaultServerUrl, id)
-      case None     => log.warnf("Failed to park expert bot on %s", defaultServerUrl)
-
-  private def park(serverUrl: String, difficulty: String): Option[String] =
-    System.getenv().asScala.get("TOURNAMENT_BOT_TOKEN").filter(_.nonEmpty).flatMap { token =>
-      Try {
-        val body = s"""{"name":"${botName(difficulty)}"}"""
-        val response = client
-          .target(serverUrl)
-          .path("api")
-          .path("bots")
-          .request(MediaType.APPLICATION_JSON)
-          .header("Authorization", s"Bearer $token")
-          .post(Entity.entity(body, MediaType.APPLICATION_JSON))
-        if response.getStatus == 201 || response.getStatus == 200 then
-          val id = objectMapper.readTree(response.readEntity(classOf[String])).path("id").asText()
-          response.close()
-          Option(id).filter(_.nonEmpty)
-        else {
-          log.warnf("Parking bot %s returned status %d", botName(difficulty), response.getStatus); response.close();
-          None
+    val token = System.getenv().asScala.get("TOURNAMENT_BOT_TOKEN").filter(_.nonEmpty)
+    token match
+      case None => log.warn("TOURNAMENT_BOT_TOKEN not set — skipping park")
+      case Some(tok) =>
+        val localAccountUrl = System.getenv().asScala.getOrElse("ACCOUNT_SERVICE_URL", "http://localhost:8083")
+        BotController.listBots.foreach(diff => parkOn(localAccountUrl, diff, tok))
+        fetchRemoteServers().foreach { serverUrl =>
+          BotController.listBots.foreach(diff => parkOn(serverUrl, diff, tok))
        }
-      }.getOrElse(None)
-    }
+
+  private def fetchRemoteServers(): List[String] =
+    Try {
+      val response = client.target(tournamentServiceUrl)
+        .path("api").path("tournament").path("servers")
+        .request(MediaType.APPLICATION_JSON).get()
+      if response.getStatus == 200 then
+        val node = objectMapper.readTree(response.readEntity(classOf[String]))
+        response.close()
+        node.path("servers").elements().asScala.toList.map(_.path("url").asText()).filter(_.nonEmpty)
+      else { response.close(); Nil }
+    }.getOrElse(Nil)
+
+  private def parkOn(serverUrl: String, difficulty: String, token: String): Unit =
+    Try {
+      val body = s"""{"name":"${botName(difficulty)}"}"""
+      val response = client.target(serverUrl).path("api").path("account").path("bots")
+        .request(MediaType.APPLICATION_JSON)
+        .header("Authorization", s"Bearer $token")
+        .post(Entity.entity(body, MediaType.APPLICATION_JSON))
+      if response.getStatus == 201 || response.getStatus == 200 then
+        val id = objectMapper.readTree(response.readEntity(classOf[String])).path("id").asText()
+        log.infof("Parked bot %s on %s as id %s", botName(difficulty), serverUrl, id)
+      else log.warnf("Park %s on %s returned status %d", botName(difficulty), serverUrl, response.getStatus)
+      response.close()
+    }.failed.foreach(ex => log.warnf(ex, "Failed to park %s on %s", botName(difficulty), serverUrl))

  private def botName(difficulty: String): String = s"NowChess ${difficulty.capitalize}"

@@ -84,7 +94,6 @@ class TournamentBotGamePlayer:
      tournamentId: String,
      botToken: Option[String],
      difficulty: String,
-      serverUrl: String,
  ): Either[String, String] =
    val resolvedToken = botToken.filter(_.nonEmpty)
      .orElse(System.getenv().asScala.get("TOURNAMENT_BOT_TOKEN").filter(_.nonEmpty))
@@ -94,7 +103,7 @@ class TournamentBotGamePlayer:
        TournamentBotConfig.jwtSubject(token) match
          case None => Left("Invalid bot token — could not extract subject")
          case Some(botId) =>
-            val cfg = TournamentBotConfig(serverUrl, tournamentId, token, botId, difficulty)
+            val cfg = TournamentBotConfig(tournamentServiceUrl, tournamentId, token, botId, difficulty)
            if join(cfg) then
              startAsync(cfg)
              Right(botId)
@@ -1,3 +1,3 @@
 MAJOR=0
-MINOR=22
+MINOR=23
 PATCH=0
@@ -37,3 +37,21 @@

 * **tournament:** replace scala.util.Random singleton with UUID for native image ([a50884a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a50884a11b1de500e74c18fd08d2d102d53cc3e9))
 * wrap server list response in ExternalTournamentServerList ([f2d79e4](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f2d79e4952aea6bde762c294eb202474b7827054))
+##  (2026-06-21)
+
+### Features
+
+* **analytics:** add Spark batch analytics module ([#70](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/70)) ([39f1657](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/39f1657e1db6e84889af338c43be8cb5c03c3ec3))
+* NCS-121 pipeline for tournament ([#68](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/68)) ([145f467](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/145f4676483f92bfe6f2d9ca40e2cb4200982e87))
+* NCS-82 add Swiss-system tournament module ([#55](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/55)) ([c5661de](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c5661de4a0ebf4b33211f5a391840dcf744656b7))
+* **reflection:** add GameWritebackEventDto to native reflection configuration ([1aee39c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1aee39c1ad286984501ac4b47da2b72d60b58a6f))
+* **reflection:** add native reflection configuration for tournament classes ([65bc6a7](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/65bc6a759937543df2d29905688bfa9e68d0c9d4))
+* **tournament:** federate tournaments across clusters with DB replication ([5b000a6](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/5b000a6e5f04ea6770d1c7ab6bfdaded77a99172))
+* **tournament:** remove dynamic server add/remove endpoints ([6d06edd](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/6d06edda69a50de65cd9efa27f26a4cc6b437f9d))
+* **tournament:** seed external server registry from env var on startup ([845dc9c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/845dc9c2935c8bc1be42541dfaf31c9a861d3272))
+
+### Bug Fixes
+
+* **tournament:** replace scala.util.Random singleton with UUID for native image ([a50884a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a50884a11b1de500e74c18fd08d2d102d53cc3e9))
+* **tournament:** use Optional[String] for selfUrl ConfigProperty to avoid startup failure ([28cbc2e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/28cbc2e18447aa8a04a5868889a49b555075d0c6))
+* wrap server list response in ExternalTournamentServerList ([f2d79e4](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f2d79e4952aea6bde762c294eb202474b7827054))
@@ -27,6 +27,9 @@ nowchess:
    prefix: ${REDIS_PREFIX:nowchess}
  internal:
    secret: ${INTERNAL_SECRET:123abc}
+  tournament:
+    self-url: ""
+    external-servers: ""

 mp:
  jwt:
@@ -46,6 +49,10 @@ mp:
    hibernate-orm:
      schema-management:
        strategy: update
+  nowchess:
+    tournament:
+      self-url: ${TOURNAMENT_SELF_URL:}
+      external-servers: ${TOURNAMENT_EXTERNAL_SERVERS:}

 "%test":
  quarkus:
@@ -26,13 +26,13 @@ import io.quarkus.runtime.annotations.RegisterForReflection
    classOf[RoundPairingsDto],
    classOf[ErrorDto],
    classOf[OkDto],
+    classOf[ReplicateTournamentRequest],
    classOf[CorePlayerInfo],
    classOf[CoreTimeControl],
    classOf[CoreCreateGameRequest],
    classOf[CoreGameResponse],
    classOf[GameWritebackEventDto],
    classOf[ExternalTournamentServer],
-    classOf[RegisterServerRequest],
    classOf[ExternalTournamentServerList],
  ),
 )
@@ -30,4 +30,7 @@ class Tournament:
  var startsAt: Instant  = uninitialized
  var winnerId: String   = uninitialized
  var winnerName: String = uninitialized
+
+  @Column(nullable = true)
+  var originServerUrl: String = null
  // scalafix:on
@@ -1,5 +1,7 @@
 package de.nowchess.tournament.dto

+import java.time.Instant
+
 case class BotRef(id: String, name: String)

 case class Clock(limit: Int, increment: Int)
@@ -72,3 +74,15 @@ case class RoundPairingsDto(round: Int, pairings: List[PairingDto])
 case class ErrorDto(error: String)

 case class OkDto(ok: Boolean = true)
+
+case class ReplicateTournamentRequest(
+    id: String,
+    fullName: String,
+    nbRounds: Int,
+    clockLimit: Int,
+    clockIncrement: Int,
+    rated: Boolean,
+    createdBy: String,
+    startsAt: Instant,
+    status: String,
+)
@@ -1,5 +1,4 @@
 package de.nowchess.tournament.dto

 case class ExternalTournamentServer(id: String, label: String, url: String)
-case class RegisterServerRequest(label: String, url: String)
 case class ExternalTournamentServerList(servers: List[ExternalTournamentServer])
@@ -9,13 +9,14 @@ import de.nowchess.tournament.service.{
  TournamentService,
  TournamentStreamManager,
 }
-import io.smallrye.mutiny.Multi
 import jakarta.annotation.security.{PermitAll, RolesAllowed}
 import jakarta.enterprise.context.ApplicationScoped
 import jakarta.inject.Inject
 import jakarta.ws.rs.*
 import jakarta.ws.rs.core.{Context, HttpHeaders, MediaType, Response, StreamingOutput}
+import org.eclipse.microprofile.config.inject.ConfigProperty
 import org.eclipse.microprofile.jwt.JsonWebToken
+import java.util.Optional
 import org.jboss.logging.Logger
 import scala.compiletime.uninitialized
 import scala.jdk.CollectionConverters.*
@@ -36,6 +37,9 @@ class TournamentResource:
  @Inject var externalClient: ExternalTournamentClient = uninitialized
  @Inject var objectMapper: ObjectMapper               = uninitialized
  @Context var headers: HttpHeaders                    = uninitialized
+
+  @ConfigProperty(name = "nowchess.tournament.self-url")
+  var selfUrl: Optional[String] = uninitialized
  // scalafix:on

  @GET
@@ -85,6 +89,12 @@ class TournamentResource:
    val userId = Option(jwt.getSubject).getOrElse("")
    val form   = CreateTournamentForm(name, nbRounds, clockLimit, clockIncrement, rated)
    val t      = tournamentService.create(userId, form)
+    selfUrl.ifPresent { url =>
+      registry.serverUrls().foreach { remoteUrl =>
+        if !externalClient.replicateTournament(remoteUrl, toReplicateRequest(t), url) then
+          log.warnf("Failed to replicate tournament %s to %s", t.id, remoteUrl)
+      }
+    }
    Response.status(Response.Status.CREATED).entity(tournamentService.toDto(t)).build()

  @GET
@@ -100,33 +110,59 @@ class TournamentResource:
          .flatMap(url => externalClient.fetch(url, id).map(node => Response.ok(node).build()))
          .getOrElse(Response.status(Response.Status.NOT_FOUND).entity(ErrorDto(s"Tournament $id not found")).build())

+  @POST
+  @Path("/replicate")
+  @PermitAll
+  def replicate(req: ReplicateTournamentRequest): Response =
+    val originUrl = Option(headers.getHeaderString("X-Origin-Url")).getOrElse("")
+    if originUrl.isEmpty then
+      Response.status(Response.Status.BAD_REQUEST).entity(ErrorDto("Missing X-Origin-Url header")).build()
+    else
+      tournamentService.get(req.id) match
+        case Some(_) => Response.status(Response.Status.CONFLICT).entity(ErrorDto("Tournament already exists")).build()
+        case None =>
+          tournamentService.replicate(req, originUrl)
+          Response.status(Response.Status.CREATED).build()
+
  @DELETE
  @Path("/{id}")
  @RolesAllowed(Array("**"))
  def terminate(@PathParam("id") id: String): Response =
    val userId = Option(jwt.getSubject).getOrElse("")
-    tournamentService.terminate(id, userId) match
-      case Right(_)    => Response.noContent().build()
-      case Left(error) => errorResponse(error)
+    tournamentService.get(id).flatMap(t => Option(t.originServerUrl)) match
+      case Some(originUrl) =>
+        val auth           = Option(headers.getHeaderString("Authorization"))
+        val (status, body) = externalClient.proxyPost(originUrl, s"api/tournament/$id", auth)
+        Response.status(status).entity(body).build()
+      case None =>
+        tournamentService.terminate(id, userId) match
+          case Right(_)    => Response.noContent().build()
+          case Left(error) => errorResponse(error)

  @POST
  @Path("/{id}/start")
  @RolesAllowed(Array("**"))
  def start(@PathParam("id") id: String): Response =
    val userId = Option(jwt.getSubject).getOrElse("")
-    tournamentService.start(id, userId) match
-      case Right(t) => Response.ok(tournamentService.toDto(t)).build()
-      case Left(error) =>
-        error match
-          case TournamentError.NotFound(_) =>
-            val auth = Option(headers.getHeaderString("Authorization"))
-            resolveServer(id)
-              .map { url =>
-                val (status, body) = externalClient.proxyPost(url, s"api/tournament/$id/start", auth)
-                Response.status(status).entity(body).build()
-              }
-              .getOrElse(errorResponse(error))
-          case _ => errorResponse(error)
+    tournamentService.get(id).flatMap(t => Option(t.originServerUrl)) match
+      case Some(originUrl) =>
+        val auth           = Option(headers.getHeaderString("Authorization"))
+        val (status, body) = externalClient.proxyPost(originUrl, s"api/tournament/$id/start", auth)
+        Response.status(status).entity(body).build()
+      case None =>
+        tournamentService.start(id, userId) match
+          case Right(t) => Response.ok(tournamentService.toDto(t)).build()
+          case Left(error) =>
+            error match
+              case TournamentError.NotFound(_) =>
+                val auth = Option(headers.getHeaderString("Authorization"))
+                resolveServer(id)
+                  .map { url =>
+                    val (status, body) = externalClient.proxyPost(url, s"api/tournament/$id/start", auth)
+                    Response.status(status).entity(body).build()
+                  }
+                  .getOrElse(errorResponse(error))
+              case _ => errorResponse(error)

  @POST
  @Path("/{id}/join")
@@ -136,21 +172,27 @@ class TournamentResource:
    if tokenType != "bot" then
      Response.status(Response.Status.FORBIDDEN).entity(ErrorDto("Only bots can join tournaments")).build()
    else
-      val botId   = Option(jwt.getSubject).getOrElse("")
-      val botName = Option(jwt.getClaim[AnyRef]("name")).map(_.toString).getOrElse(botId)
-      tournamentService.join(id, botId, botName) match
-        case Right(_) => Response.ok(OkDto()).build()
-        case Left(error) =>
-          error match
-            case TournamentError.NotFound(_) =>
-              val auth = Option(headers.getHeaderString("Authorization"))
-              resolveServer(id)
-                .map { url =>
-                  val (status, body) = externalClient.proxyPost(url, s"api/tournament/$id/join", auth)
-                  Response.status(status).entity(body).build()
-                }
-                .getOrElse(errorResponse(error))
-            case _ => errorResponse(error)
+      tournamentService.get(id).flatMap(t => Option(t.originServerUrl)) match
+        case Some(originUrl) =>
+          val auth           = Option(headers.getHeaderString("Authorization"))
+          val (status, body) = externalClient.proxyPost(originUrl, s"api/tournament/$id/join", auth)
+          Response.status(status).entity(body).build()
+        case None =>
+          val botId   = Option(jwt.getSubject).getOrElse("")
+          val botName = Option(jwt.getClaim[AnyRef]("name")).map(_.toString).getOrElse(botId)
+          tournamentService.join(id, botId, botName) match
+            case Right(_) => Response.ok(OkDto()).build()
+            case Left(error) =>
+              error match
+                case TournamentError.NotFound(_) =>
+                  val auth = Option(headers.getHeaderString("Authorization"))
+                  resolveServer(id)
+                    .map { url =>
+                      val (status, body) = externalClient.proxyPost(url, s"api/tournament/$id/join", auth)
+                      Response.status(status).entity(body).build()
+                    }
+                    .getOrElse(errorResponse(error))
+                case _ => errorResponse(error)

  @POST
  @Path("/{id}/withdraw")
@@ -160,20 +202,26 @@ class TournamentResource:
    if tokenType != "bot" then
      Response.status(Response.Status.FORBIDDEN).entity(ErrorDto("Only bots can withdraw")).build()
    else
-      val botId = Option(jwt.getSubject).getOrElse("")
-      tournamentService.withdraw(id, botId) match
-        case Right(_) => Response.ok(OkDto()).build()
-        case Left(error) =>
-          error match
-            case TournamentError.NotFound(_) =>
-              val auth = Option(headers.getHeaderString("Authorization"))
-              resolveServer(id)
-                .map { url =>
-                  val (status, body) = externalClient.proxyPost(url, s"api/tournament/$id/withdraw", auth)
-                  Response.status(status).entity(body).build()
-                }
-                .getOrElse(errorResponse(error))
-            case _ => errorResponse(error)
+      tournamentService.get(id).flatMap(t => Option(t.originServerUrl)) match
+        case Some(originUrl) =>
+          val auth           = Option(headers.getHeaderString("Authorization"))
+          val (status, body) = externalClient.proxyPost(originUrl, s"api/tournament/$id/withdraw", auth)
+          Response.status(status).entity(body).build()
+        case None =>
+          val botId = Option(jwt.getSubject).getOrElse("")
+          tournamentService.withdraw(id, botId) match
+            case Right(_) => Response.ok(OkDto()).build()
+            case Left(error) =>
+              error match
+                case TournamentError.NotFound(_) =>
+                  val auth = Option(headers.getHeaderString("Authorization"))
+                  resolveServer(id)
+                    .map { url =>
+                      val (status, body) = externalClient.proxyPost(url, s"api/tournament/$id/withdraw", auth)
+                      Response.status(status).entity(body).build()
+                    }
+                    .getOrElse(errorResponse(error))
+                case _ => errorResponse(error)

  @GET
  @Path("/{id}/results")
@@ -236,15 +284,81 @@ class TournamentResource:
  @Path("/{id}/stream")
  @RolesAllowed(Array("**"))
  @Produces(Array("application/x-ndjson"))
-  def stream(@PathParam("id") id: String): Multi[String] =
+  def stream(@PathParam("id") id: String): Response =
    tournamentService.get(id) match
-      case None => Multi.createFrom().failure(new NotFoundException(s"Tournament $id not found"))
+      case Some(t) if Option(t.originServerUrl).isDefined =>
+        val auth = Option(headers.getHeaderString("Authorization"))
+        externalClient.proxyGetStream(t.originServerUrl, s"api/tournament/$id/stream", auth)
+          .map { inputStream =>
+            Response
+              .ok(new StreamingOutput {
+                def write(output: java.io.OutputStream): Unit =
+                  val buf = new Array[Byte](4096)
+                  // scalafix:off DisableSyntax.var
+                  var n = inputStream.read(buf)
+                  while n >= 0 do
+                    output.write(buf, 0, n)
+                    output.flush()
+                    n = inputStream.read(buf)
+                // scalafix:on
+              })
+              .`type`("application/x-ndjson")
+              .build()
+          }
+          .getOrElse(Response.status(Response.Status.NOT_FOUND).entity(ErrorDto(s"Tournament $id stream unavailable")).build())
      case Some(_) =>
        val botId = Option(jwt.getSubject).getOrElse("")
-        Multi.createFrom().emitter[String] { emitter =>
-          streamManager.register(id, botId, emitter)
-          emitter.onTermination(() => streamManager.unregister(id, botId, emitter))
+        val queue   = new java.util.concurrent.LinkedBlockingQueue[Option[String]]()
+        val emitter = new io.smallrye.mutiny.subscription.MultiEmitter[String] {
+          def emit(item: String): io.smallrye.mutiny.subscription.MultiEmitter[String] =
+            queue.put(Some(item)); this
+          def fail(failure: Throwable): Unit = queue.put(None)
+          def complete(): Unit               = queue.put(None)
+          def requested(): Long              = Long.MaxValue
+          def isCancelled: Boolean           = false
+          def onTermination(
+              onTermination: java.lang.Runnable,
+          ): io.smallrye.mutiny.subscription.MultiEmitter[String] = this
        }
+        streamManager.register(id, botId, emitter)
+        Response
+          .ok(new StreamingOutput {
+            def write(output: java.io.OutputStream): Unit =
+              try
+                // scalafix:off DisableSyntax.var
+                var cont = true
+                while cont do
+                  queue.take() match
+                    case None       => cont = false
+                    case Some(line) =>
+                      output.write((line + "\n").getBytes("UTF-8"))
+                      output.flush()
+                // scalafix:on
+              finally streamManager.unregister(id, botId, emitter)
+          })
+          .`type`("application/x-ndjson")
+          .build()
+      case None =>
+        val auth = Option(headers.getHeaderString("Authorization"))
+        resolveServer(id)
+          .flatMap(url => externalClient.proxyGetStream(url, s"api/tournament/$id/stream", auth))
+          .map { inputStream =>
+            Response
+              .ok(new StreamingOutput {
+                def write(output: java.io.OutputStream): Unit =
+                  val buf = new Array[Byte](4096)
+                  // scalafix:off DisableSyntax.var
+                  var n = inputStream.read(buf)
+                  while n >= 0 do
+                    output.write(buf, 0, n)
+                    output.flush()
+                    n = inputStream.read(buf)
+                // scalafix:on
+              })
+              .`type`("application/x-ndjson")
+              .build()
+          }
+          .getOrElse(Response.status(Response.Status.NOT_FOUND).entity(ErrorDto(s"Tournament $id not found")).build())

  @GET
  @Path("/{id}/game/{gameId}")
@@ -297,15 +411,31 @@ class TournamentResource:
      .getOrElse(Response.status(Response.Status.NOT_FOUND).build())

  private def resolveServer(tournamentId: String): Option[String] =
-    registry.findServerUrl(tournamentId).orElse {
-      registry
-        .serverUrls()
-        .find(url => externalClient.fetch(url, tournamentId).isDefined)
-        .map { url =>
-          registry.bindTournament(tournamentId, url)
-          url
-        }
-    }
+    tournamentService.get(tournamentId)
+      .flatMap(t => Option(t.originServerUrl))
+      .orElse(registry.findServerUrl(tournamentId))
+      .orElse {
+        registry
+          .serverUrls()
+          .find(url => externalClient.fetch(url, tournamentId).isDefined)
+          .map { url =>
+            registry.bindTournament(tournamentId, url)
+            url
+          }
+      }
+
+  private def toReplicateRequest(t: de.nowchess.tournament.domain.Tournament): ReplicateTournamentRequest =
+    ReplicateTournamentRequest(
+      id = t.id,
+      fullName = t.fullName,
+      nbRounds = t.nbRounds,
+      clockLimit = t.clockLimit,
+      clockIncrement = t.clockIncrement,
+      rated = t.rated,
+      createdBy = t.createdBy,
+      startsAt = Option(t.startsAt).getOrElse(java.time.Instant.now()),
+      status = t.status,
+    )

  private def errorResponse(error: TournamentError): Response =
    val status = error match
@@ -1,6 +1,6 @@
 package de.nowchess.tournament.resource

-import de.nowchess.tournament.dto.{ErrorDto, ExternalTournamentServerList, RegisterServerRequest}
+import de.nowchess.tournament.dto.ExternalTournamentServerList
 import de.nowchess.tournament.service.TournamentServerRegistry
 import jakarta.annotation.security.RolesAllowed
 import jakarta.enterprise.context.ApplicationScoped
@@ -23,13 +23,3 @@ class TournamentServerResource:
  @GET
  def list(): Response =
    Response.ok(ExternalTournamentServerList(registry.list())).build()
-
-  @POST
-  def register(req: RegisterServerRequest): Response =
-    Response.status(201).entity(registry.register(req.label, req.url)).build()
-
-  @DELETE
-  @Path("/{id}")
-  def remove(@PathParam("id") id: String): Response =
-    if registry.remove(id) then Response.noContent().build()
-    else Response.status(Response.Status.NOT_FOUND).entity(ErrorDto(s"Server $id not found")).build()
@@ -1,6 +1,7 @@
 package de.nowchess.tournament.service

 import com.fasterxml.jackson.databind.{JsonNode, ObjectMapper}
+import de.nowchess.tournament.dto.ReplicateTournamentRequest
 import jakarta.enterprise.context.ApplicationScoped
 import jakarta.inject.Inject
 import jakarta.ws.rs.client.{Client, ClientBuilder, Entity}
@@ -66,6 +67,21 @@ class ExternalTournamentClient:
        client.close()
    }.getOrElse((502, """{"error":"External server unreachable"}"""))

+  def replicateTournament(serverUrl: String, req: ReplicateTournamentRequest, selfUrl: String): Boolean =
+    Try {
+      val client  = buildClient()
+      val body    = objectMapper.writeValueAsString(req)
+      val response = client
+        .target(s"$serverUrl/api/tournament/replicate")
+        .request(MediaType.APPLICATION_JSON)
+        .header("X-Origin-Url", selfUrl)
+        .post(Entity.entity(body, MediaType.APPLICATION_JSON))
+      try response.getStatus / 100 == 2
+      finally
+        response.close()
+        client.close()
+    }.getOrElse(false)
+
  def proxyGetStream(serverUrl: String, path: String, authHeader: Option[String]): Option[java.io.InputStream] =
    Try {
      val client   = buildClient()
@@ -1,17 +1,29 @@
 package de.nowchess.tournament.service

 import de.nowchess.tournament.dto.ExternalTournamentServer
+import jakarta.annotation.PostConstruct
 import jakarta.enterprise.context.ApplicationScoped
-import java.util.UUID
+import org.eclipse.microprofile.config.inject.ConfigProperty
+import java.util.{Optional, UUID}
 import java.util.concurrent.ConcurrentHashMap
 import scala.jdk.CollectionConverters.*

@ApplicationScoped
 class TournamentServerRegistry:

+  @ConfigProperty(name = "nowchess.tournament.external-servers")
+  var externalServers: Optional[String] = scala.compiletime.uninitialized
+
  private val servers     = new ConcurrentHashMap[String, ExternalTournamentServer]()
  private val tournaments = new ConcurrentHashMap[String, String]()

+  @PostConstruct
+  def init(): Unit =
+    if externalServers.isPresent then
+      externalServers.get().split(",").map(_.trim).filter(_.nonEmpty).foreach { url =>
+        register(url, url)
+      }
+
  def register(label: String, url: String): ExternalTournamentServer =
    val id     = UUID.randomUUID().toString
    val server = ExternalTournamentServer(id, label, url.stripSuffix("/"))
@@ -9,6 +9,7 @@ import de.nowchess.tournament.dto.{
  Clock,
  CreateTournamentForm,
  PairingDto,
+  ReplicateTournamentRequest,
  ResultDto,
  Standing,
  TournamentDto,
@@ -61,6 +62,23 @@ class TournamentService:
    tournamentRepository.persist(t)
    t

+  @Transactional
+  def replicate(req: ReplicateTournamentRequest, originServerUrl: String): Tournament =
+    val t = new Tournament()
+    t.id = req.id
+    t.fullName = req.fullName
+    t.nbRounds = req.nbRounds
+    t.clockLimit = req.clockLimit
+    t.clockIncrement = req.clockIncrement
+    t.rated = req.rated
+    t.status = req.status
+    t.currentRound = 0
+    t.createdBy = req.createdBy
+    t.startsAt = req.startsAt
+    t.originServerUrl = originServerUrl
+    tournamentRepository.persist(t)
+    t
+
  def get(id: String): Option[Tournament] =
    tournamentRepository.findOptById(id)

@@ -1,3 +1,3 @@
 MAJOR=0
-MINOR=4
+MINOR=5
 PATCH=0
Author	SHA1	Message	Date
TeamCity	a63d195cb3	ci: bump version with Build-134	2026-06-21 20:12:06 +00:00
Janis Eccarius	28cbc2e184	fix(tournament): use Optional[String] for selfUrl ConfigProperty to avoid startup failure Build & Test (NowChessSystems) TeamCity build finished Details Empty string config value caused DeploymentException when injected as String. Optional[String] handles absent/empty cleanly without defaultValue workaround. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-21 21:50:00 +02:00
Janis Eccarius	1be9949c0b	fix(official-bots): correct parkOn path from /api/bots to /api/account/bots Build & Test (NowChessSystems) TeamCity build was removed from queue Details Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-21 21:47:05 +02:00
Janis Eccarius	6d06edda69	feat(tournament): remove dynamic server add/remove endpoints Build & Test (NowChessSystems) TeamCity build failed Details Servers are now configured via TOURNAMENT_EXTERNAL_SERVERS env var. POST /api/tournament/servers and DELETE /api/tournament/servers/{id} are removed; only GET (list) remains for the bot's fetchRemoteServers call. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-21 21:37:29 +02:00
Janis Eccarius	845dc9c293	feat(tournament): seed external server registry from env var on startup Build & Test (NowChessSystems) TeamCity build was queued Details TOURNAMENT_EXTERNAL_SERVERS (comma-separated URLs) is loaded into TournamentServerRegistry at startup so the bot can park on all servers and replication targets are known without manual API calls after each restart. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-21 21:33:57 +02:00
Janis Eccarius	5b000a6e5f	feat(tournament): federate tournaments across clusters with DB replication Build & Test (NowChessSystems) TeamCity build failed Details - Replicate newly created tournaments to all registered remote servers, persisting them with originServerUrl so the remote can proxy mutations back - Route all mutation endpoints (join/start/terminate/withdraw) through originServerUrl when set, instead of trying local state first - Fix tournament event stream to proxy remote tournaments (was 404 before) - Official bot now routes all calls through TOURNAMENT_SERVICE_URL (local tournament service) instead of calling remote cluster directly - Bot parks on local account service + all registered remote servers on startup - Add TOURNAMENT_SELF_URL env var so each cluster knows its own public URL Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-21 21:24:21 +02:00
TeamCity	97015cb95e	ci: bump version with Build-133	2026-06-21 14:51:19 +00:00
Janis Eccarius	a268a9acb7	fix(analytics): write decompressed PGN to shared PVC path for executor access Build & Test (NowChessSystems) TeamCity build finished Details SparkFiles.get() on the driver returns a driver-local path. When this was passed to spark.read.text() the executor tried to open that path on its own filesystem (separate pod), silently reading 0 rows. Fix: download and decompress the Lichess PGN to NOWCHESS_PGN_CACHE_DIR (default /tmp) which must be a filesystem shared between driver and executor pods. In the k8s deployment this is the spark-analytics-output PVC mounted at /spark-output, so set NOWCHESS_PGN_CACHE_DIR=/spark-output/.pgn-cache. Also caches the decompressed file across runs — skips download if already present. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-21 16:31:05 +02:00