Print messages on start and shutdown

Package.swift

@@ -2,7 +2,7 @@
 import PackageDescription
 
 let package = Package(
-    name: "SchafkopfServer",
+    name: "Schafkopf-Server",
     platforms: [
        .macOS(.v12)
     ],
@@ -20,7 +20,7 @@ let package = Package(
         .package(url: "https://github.com/christophhagen/ClairvoyantBinaryCodable", from: "0.3.1"),
     ],
     targets: [
-        .target(
+        .executableTarget(
             name: "App",
             dependencies: [
                 .product(name: "Fluent", package: "fluent"),
@@ -30,18 +30,7 @@ let package = Package(
                 .product(name: "Clairvoyant", package: "Clairvoyant"),
                 .product(name: "ClairvoyantVapor", package: "ClairvoyantVapor"),
                 .product(name: "ClairvoyantBinaryCodable", package: "ClairvoyantBinaryCodable"),
-            ],
+            ]
-            swiftSettings: [
+        )
-                // Enable better optimizations when building in Release configuration. Despite the use of
-                // the `.unsafeFlags` construct required by SwiftPM, this flag is recommended for Release
-                // builds. See <https://github.com/swift-server/guides/blob/main/docs/building.md#building-for-production> for details.
-                .unsafeFlags(["-cross-module-optimization"], .when(configuration: .release))
-            ]
-        ),
-        .executableTarget(name: "Run", dependencies: [.target(name: "App")]),
-//        .testTarget(name: "AppTests", dependencies: [
-//            .target(name: "App"),
-//            .product(name: "XCTVapor", package: "vapor"),
-//        ])
     ]
 )

Public/api.js

@@ -8,7 +8,7 @@
  If the server runs under https://example.com/schafkopf
  then apiPath = "/schafkopf"
  */
-const apiPath = "/schafkopf"
+const apiPath = ""
 
 var useEnglishTexts = false
 

Resources/config_example.json

@@ -1,6 +1,5 @@
 {
     "serverPort": 8000,
-    "production": false,
     "mail": {
         "serverDomain": "https://example.com/schafkopf",
         "emailHostname": "example.com",
@@ -9,4 +8,5 @@
         "tokenExpiryDuration": 15,
     },
     "monitoringTokens": [],
+    "dataDirectory" : "/data/schafkopf"
 }

Sources/App/EventLoopScheduler.swift

@@ -1,34 +1,10 @@
 import Foundation
-import Clairvoyant
 import Vapor
-import NIOCore
+import Clairvoyant
 
-final class EventLoopScheduler {
+extension MultiThreadedEventLoopGroup: AsyncScheduler {
-
-    private let backgroundGroup: EventLoopGroup
-
-    init(numberOfThreads: Int = 2) {
-        backgroundGroup = MultiThreadedEventLoopGroup(numberOfThreads: numberOfThreads)
-    }
-
-    func next() -> EventLoop {
-        backgroundGroup.next()
-    }
-
-    func provider() -> NIOEventLoopGroupProvider {
-        return .shared(backgroundGroup)
-    }
-
-    func shutdown() {
-        backgroundGroup.shutdownGracefully { _ in
 
-        }
+    public func schedule(asyncJob: @escaping @Sendable () async throws -> Void) {
-    }
+        _ = any().makeFutureWithTask(asyncJob)
-}
-
-extension EventLoopScheduler: AsyncScheduler {
-
-    func schedule(asyncJob: @escaping @Sendable () async throws -> Void) {
-        _ = backgroundGroup.any().makeFutureWithTask(asyncJob)
     }
 }

Sources/App/Management/Configuration.swift

@@ -6,13 +6,6 @@ struct Configuration {
 
     let mail: EMail?
 
-    /**
-     Use a database file and reduce logging.
-
-     If this property is set to `false`, then an in-memory database is used with increased logging.
-     */
-    let production: Bool
-
     struct EMail {
 
         /// The url to the root of the server
@@ -31,8 +24,38 @@ struct Configuration {
         let tokenExpiryDuration: Int
     }
     
+    /**
+     The folder where the data should be stored.
+     
+     If the folder is set to `nil`, then the `Resources` folder is used.
+     */
+    let dataDirectory: String?
+
     /// The authentication tokens to access the metrics
     let monitoringTokens: Set<String>
+    
+    /// The path to the folder where the metric logs are stored
+    ///
+    /// If no path is provided, then a folder `logs` in the resources directory is created
+    /// If the path is relative, then it is assumed relative to the resources directory
+    let logPath: String?
+    
+    func logURL(possiblyRelativeTo resourcesDirectory: URL) -> URL {
+        guard let logPath else {
+            return resourcesDirectory.appendingPathComponent("logs")
+        }
+        guard !logPath.hasPrefix("/") else {
+            return .init(fileURLWithPath: logPath)
+        }
+        return resourcesDirectory.appendingPathComponent(logPath)
+    }
+    
+    func customDataDirectory(or publicDirectory: String) -> URL {
+        guard let dataDirectory else {
+            return URL(fileURLWithPath: publicDirectory)
+        }
+        return URL(fileURLWithPath: dataDirectory)
+    }
 }
 
 extension Configuration {

Sources/App/Management/SQLiteDatabase.swift

@@ -37,7 +37,7 @@ private extension Configuration.EMail {
     }
 }
 
-final class SQLiteDatabase {
+actor SQLiteDatabase {
 
     /// A mapping between player name and generated access tokens for a session
     private var sessionTokenForPlayer = [PlayerName: SessionToken]()
@@ -51,6 +51,13 @@ final class SQLiteDatabase {
 
     private let registeredPlayerCountMetric: Metric<Int>
     
+    private let dateFormatter = DateFormatter()
+    
+    func printServerStartMessage() async {
+        let players = await registeredPlayerCountMetric.lastValue()?.value ?? 0
+        log("[\(dateFormatter.string(from: Date()))] Server started (\(players) players, \(tables.tableCount) tables)")
+    }
+
     init(database: Database, mail: Configuration.EMail?) async throws {
         self.registeredPlayerCountMetric = Metric(
             "schafkopf.players",
@@ -60,6 +67,9 @@ final class SQLiteDatabase {
         self.mail = mail?.mailConfig
 
         await updateRegisteredPlayerCount(from: database)
+        
+        dateFormatter.dateStyle = .short
+        dateFormatter.timeStyle = .short
     }
 
     func registerPlayer(named name: PlayerName, hash: PasswordHash, email: String?, in database: Database) async throws -> SessionToken {
@@ -87,9 +97,13 @@ final class SQLiteDatabase {
         return token
     }
     
+    private func playerCount(in database: Database) async throws -> Int {
+        try await User.query(on: database).count()
+    }
+
     func updateRegisteredPlayerCount(from database: Database) async {
         do {
-            let count = try await User.query(on: database).count()
+            let count = try await playerCount(in: database)
             _ = try? await registeredPlayerCountMetric.update(count)
         } catch {
             log("Failed to update player count metric: \(error)")
@@ -207,18 +221,18 @@ final class SQLiteDatabase {
         playerNameForToken[token] != nil
     }
 
-    func startSession(socket: WebSocket, sessionToken token: SessionToken) -> Bool {
+    func startSession(socket: WebSocket, sessionToken token: SessionToken) async -> Bool {
         guard let player = playerNameForToken[token] else {
             return false
         }
-        return tables.connect(player: player, using: socket)
+        return await tables.connect(player: player, using: socket)
     }
 
-    func endSession(forSessionToken sessionToken: SessionToken) {
+    func endSession(forSessionToken sessionToken: SessionToken) async {
         guard let player = endExistingSession(forSessionToken: sessionToken) else {
             return
         }
-        tables.disconnect(player: player)
+        await tables.disconnect(player: player)
     }
 
     private func endExistingSession(forSessionToken token: SessionToken) -> PlayerName? {
@@ -320,7 +334,12 @@ final class SQLiteDatabase {
         return try await tables.play(card: card, player: player, in: database)
     }
     
-    func disconnectAllSockets() {
+    func shutdown() async {
-        tables.disconnectAllSockets()
+        await disconnectAllSockets()
+        log("[\(dateFormatter.string(from: Date()))] Server shutdown")
+    }
+    
+    private func disconnectAllSockets() async {
+        await tables.disconnectAllSockets()
     }
 }

Sources/App/Management/TableManagement.swift

@@ -23,6 +23,10 @@ final class TableManagement {
     /// The metric describing the number of players currently connected via a websocket
     private let connectedPlayerCountMetric: Metric<Int>
     
+    var tableCount: Int {
+        tables.count
+    }
+
     /**
      Load the tables from a file in the storage folder
      - Throws: Errors when the file could not be read
@@ -58,7 +62,6 @@ final class TableManagement {
             let id = table.id!
             self.tables[id] = WaitingTable(id: id, name: table.name, isPublic: table.isPublic, players: table.players)
         }
-        log("\(tables.count) tables loaded")
         await logTableCount()
         await logPlayingPlayerCount()
         await logConnectedPlayerCount()
@@ -172,26 +175,22 @@ final class TableManagement {
         try await player.update(on: database)
     }
     
-    func connect(player: PlayerName, using socket: WebSocket) -> Bool {
+    func connect(player: PlayerName, using socket: WebSocket) async -> Bool {
         guard let table = currentTable(for: player) else {
             return false
         }
         let result = table.connect(player: player, using: socket)
-        Task {
         await logConnectedPlayerCount()
-        }
         return result
     }
     
-    func disconnect(player: PlayerName) {
+    func disconnect(player: PlayerName) async {
         guard let table = currentTable(for: player) else {
             return
         }
         table.disconnect(player: player)
-        Task {
         await logConnectedPlayerCount()
     }
-    }
     
     func performAction(player: PlayerName, action: PlayerAction) -> PlayerActionResult {
         guard let table = currentTable(for: player) else {
@@ -257,10 +256,8 @@ final class TableManagement {
         return .success
     }
     
-    func disconnectAllSockets() {
+    func disconnectAllSockets() async {
         tables.values.forEach { $0.disconnectAllPlayers() }
-        Task {
         await logConnectedPlayerCount()
     }
 }
-}

Sources/App/configure.swift

@@ -7,20 +7,18 @@ import ClairvoyantVapor
 var server: SQLiteDatabase!
 
 private var provider: VaporMetricProvider! = nil
-private let scheduler = EventLoopScheduler()
 private var status: Metric<ServerStatus>!
+private let scheduler = MultiThreadedEventLoopGroup(numberOfThreads: 2)
 
-private func update(status newStatus: ServerStatus) {
+func configure(_ app: Application) async throws {
-    scheduler.schedule {
+    let resourceFolder = URL(fileURLWithPath: app.directory.resourcesDirectory)
-        _ = try? await status.update(newStatus)
+    let publicDirectory = app.directory.publicDirectory
-    }
-}
     
-// configures your application
+    let configPath = URL(fileURLWithPath: app.directory.resourcesDirectory)
-public func configure(_ app: Application) async throws {
+        .appendingPathComponent("config.json")
-    let storageFolder = URL(fileURLWithPath: app.directory.resourcesDirectory)
+    let configuration = try Configuration(loadFromUrl: configPath)
 
-    let logFolder = storageFolder.appendingPathComponent("logs")
+    let logFolder = configuration.logURL(possiblyRelativeTo: resourceFolder)
     let monitor = MetricObserver(
         logFileFolder: logFolder,
         logMetricId: "schafkopf.log")
@@ -31,37 +29,22 @@ public func configure(_ app: Application) async throws {
         name: "Status",
         description: "The main status of the server")
     
-    update(status: .initializing)
+    try await status.update(.initializing)
-
-    let configPath = URL(fileURLWithPath: app.directory.resourcesDirectory)
-        .appendingPathComponent("config.json")
-    let configuration: Configuration
-
-    do {
-        configuration = try Configuration(loadFromUrl: configPath)
-    } catch {
-        update(status: .initializationFailure)
-        await monitor.log("Failed to read configuration: \(error)")
-        // Note: If configuration can't be loaded, then the server will run on the wrong port
-        // and access to metrics is impossible, since no tokens are loaded
-        return
-    }
 
     app.http.server.configuration.port = configuration.serverPort
 
-    // Set target environment
+    switch app.environment {
-    app.environment = .production
+    case .production:
-
-    if !configuration.production {
-        app.logger.logLevel = .info
-        log("[DEVELOPMENT] Using in-memory database")
-        app.databases.use(.sqlite(.memory), as: .sqlite)
-    } else {
         app.logger.logLevel = .notice
-        let dbFile = storageFolder.appendingPathComponent("db.sqlite").path
+        let dataDirectory = configuration.customDataDirectory(or: publicDirectory)
+        let dbFile = dataDirectory.appendingPathComponent("db.sqlite").path
         log("[PRODUCTION] Using database at \(dbFile)")
         app.databases.use(.sqlite(.file(dbFile)), as: .sqlite)
+    default:
+        log("[DEVELOPMENT] Using in-memory database")
+        app.databases.use(.sqlite(.memory), as: .sqlite)
     }
+
     app.migrations.add(UserTableMigration())
     app.migrations.add(PasswordResetMigration())
 
@@ -69,7 +52,7 @@ public func configure(_ app: Application) async throws {
         try await app.autoMigrate()
     } catch {
         await monitor.log("Failed to migrate database: \(error)")
-        update(status: .initializationFailure)
+        try await status.update(.initializationFailure)
         return
     }
 
@@ -79,13 +62,6 @@ public func configure(_ app: Application) async throws {
     let db = app.databases.database(.sqlite, logger: .init(label: "Init"), on: app.databases.eventLoopGroup.next())!
     server = try await SQLiteDatabase(database: db, mail: configuration.mail)
     
-    // Gracefully shut down by closing potentially open socket
-    DispatchQueue.global(qos: .utility).asyncAfter(deadline: .now() + .seconds(5)) {
-        _ = app.server.onShutdown.always { _ in
-            server.disconnectAllSockets()
-        }
-    }
-
     // register routes
     routes(app)
 
@@ -93,8 +69,17 @@ public func configure(_ app: Application) async throws {
     provider = .init(observer: monitor, accessManager: configuration.monitoringTokens)
     provider.asyncScheduler = scheduler
     provider.registerRoutes(app)
+    monitor.saveCurrentListOfMetricsToLogFolder()
 
-    update(status: .nominal)
+    try await status.update(.nominal)
+    await server.printServerStartMessage()
+}
+
+func shutdown() {
+    Task {
+        await server.shutdown()
+        try await scheduler.shutdownGracefully()
+    }
 }
 
 func log(_ message: String) {

Sources/App/entrypoint.swift

@@ -0,0 +1,43 @@
+import Vapor
+import Dispatch
+import Logging
+
+/// This extension is temporary and can be removed once Vapor gets this support.
+private extension Vapor.Application {
+    static let baseExecutionQueue = DispatchQueue(label: "vapor.codes.entrypoint")
+    
+    func runFromAsyncMainEntrypoint() async throws {
+        try await withCheckedThrowingContinuation { continuation in
+            Vapor.Application.baseExecutionQueue.async { [self] in
+                do {
+                    try self.run()
+                    continuation.resume()
+                } catch {
+                    continuation.resume(throwing: error)
+                }
+            }
+        }
+    }
+}
+
+@main
+enum Entrypoint {
+    static func main() async throws {
+        var env = try Environment.detect()
+        try LoggingSystem.bootstrap(from: &env)
+        
+        let app = Application(env)
+        defer {
+            shutdown()
+            app.shutdown()
+        }
+        
+        do {
+            try await configure(app)
+        } catch {
+            app.logger.report(error: error)
+            throw error
+        }
+        try await app.runFromAsyncMainEntrypoint()
+    }
+}

Sources/App/routes.swift

@@ -156,7 +156,7 @@ func loginPlayer(_ app: Application) {
         guard try request.password.verify(password, created: hash) else {
             throw Abort(.unauthorized) // 401
         }
-        return server.startNewSessionForRegisteredPlayer(named: name)
+        return await server.startNewSessionForRegisteredPlayer(named: name)
     }
 }
 
@@ -177,7 +177,7 @@ func resumeSession(_ app: Application) {
     app.post("player", "resume") { request -> String in
         let token = try request.header(.token)
         
-        guard let player = server.registeredPlayerExists(withSessionToken: token) else {
+        guard let player = await server.registeredPlayerExists(withSessionToken: token) else {
             throw Abort(.unauthorized) // 401
         }
         return player
@@ -199,7 +199,7 @@ func logoutPlayer(_ app: Application) {
     app.post("player", "logout") { request -> HTTPResponseStatus in
         let token = try request.header(.token)
 
-        server.endSession(forSessionToken: token)
+        await server.endSession(forSessionToken: token)
         return .ok
     }
 }
@@ -221,10 +221,10 @@ func getTableForPlayer(_ app: Application) {
     app.post("player", "table") { request -> String in
         let token = try request.header(.token)
 
-        guard let player = server.registeredPlayerExists(withSessionToken: token) else {
+        guard let player = await server.registeredPlayerExists(withSessionToken: token) else {
             throw Abort(.unauthorized) // 401
         }
-        guard let info = server.currentTableOfPlayer(named: player) else {
+        guard let info = await server.currentTableOfPlayer(named: player) else {
             return ""
         }
         return try encodeJSON(info)
@@ -239,8 +239,8 @@ func getTableForPlayer(_ app: Application) {
 func openWebsocket(_ app: Application) {
     app.webSocket("session", "start") { req, socket in
         socket.onText { socket, text in
-            guard server.startSession(socket: socket, sessionToken: text) else {
+            guard await server.startSession(socket: socket, sessionToken: text) else {
-                _ = socket.close()
+                try? await socket.close()
                 return
             }
         }
@@ -279,7 +279,7 @@ func createTable(_ app: Application) {
             throw Abort(.badRequest) // 400
         }
         
-        guard let player = server.registeredPlayerExists(withSessionToken: token) else {
+        guard let player = await server.registeredPlayerExists(withSessionToken: token) else {
             throw Abort(.unauthorized) // 401
         }
         let result = try await server.createTable(named: tableName, player: player, isPublic: isPublic, in: request.db)
@@ -304,10 +304,10 @@ func getPublicTables(_ app: Application) {
     app.post("tables", "public") { request -> String in
         let token = try request.header(.token)
 
-        guard server.isValid(sessionToken: token) else {
+        guard await server.isValid(sessionToken: token) else {
             throw Abort(.unauthorized) // 401
         }
-        let list = server.getPublicTableInfos()
+        let list = await server.getPublicTableInfos()
         return try encodeJSON(list)
     }
 }
@@ -376,9 +376,9 @@ func performActionForPlayer(_ app: Application) {
 
         let result: PlayerActionResult
         if let action = PlayerAction(rawValue: actionString) {
-            result = server.performAction(playerToken: token, action: action)
+            result = await server.performAction(playerToken: token, action: action)
         } else if let game = GameType(rawValue: actionString) {
-            result = server.select(game: game, playerToken: token)
+            result = await server.select(game: game, playerToken: token)
         } else {
             throw Abort(.badRequest)
         }

Sources/Run/main.swift

@@ -1,15 +0,0 @@
-import App
-import Vapor
-
-var env = try Environment.detect()
-try LoggingSystem.bootstrap(from: &env)
-let app = Application(env)
-defer { app.shutdown() }
-
-private let semaphore = DispatchSemaphore(value: 0)
-Task {
-    try await configure(app)
-    semaphore.signal()
-}
-semaphore.wait()
-try app.run()

Tests/AppTests/AppTests.swift

@@ -1,15 +0,0 @@
-@testable import App
-import XCTVapor
-
-final class AppTests: XCTestCase {
-    func testHelloWorld() throws {
-        let app = Application(.testing)
-        defer { app.shutdown() }
-        try configure(app)
-
-        try app.test(.GET, "hello", afterResponse: { res in
-            XCTAssertEqual(res.status, .ok)
-            XCTAssertEqual(res.body.string, "Hello, world!")
-        })
-    }
-}