Free fork of NotProton: Windows Steam games in Mac Steam, on CodeWeavers' Wine and Apple's Game Porting Toolkit
Swift apple-silicond3dmetaldxmtdxvkgame-porting-toolkitgptkmac-gamingmacosmetalfxrosetta-2steamsteam-playwinewinecx
fix(reports): bound uploads by encoded JSON size (#854)
Louis Hinchliffee23c4edc26de
diff --git a/app/Sources/BridgeplayApp/Model/PlayReports.swift b/app/Sources/BridgeplayApp/Model/PlayReports.swiftindex 794de81..263d92b 100644--- a/app/Sources/BridgeplayApp/Model/PlayReports.swift+++ b/app/Sources/BridgeplayApp/Model/PlayReports.swift@@ -29,9 +29,41 @@ struct ReportPayload: Codable, Equatable, Sendable {var log: String?var wineLog: String?- // Together under the endpoint's 1 MB cap, newest lines kept.+ // Newest lines kept. These count characters, not bytes, so encoded() is what keeps the+ // JSON under the endpoint's 1 MB cap.static let logLimit = 550_000static let wineLogLimit = 350_000+ static let maximumEncodedSize = 1_000_000++ func encoded() throws -> Data {+ let encoder = JSONEncoder()+ let full = try encoder.encode(self)+ guard full.count > Self.maximumEncodedSize else { return full }++ var trimmed = self+ trimmed.log = nil+ trimmed.wineLog = nil+ var result = try encoder.encode(trimmed)+ guard result.count <= Self.maximumEncodedSize else {+ throw EncodingError.invalidValue(self, .init(codingPath: [], debugDescription: "Report metadata exceeds the upload limit."))+ }++ var lower = 0+ var upper = max(log?.count ?? 0, wineLog?.count ?? 0)+ while lower <= upper {+ let limit = lower + (upper - lower) / 2+ trimmed.log = log.map { String($0.suffix(limit)) }+ trimmed.wineLog = wineLog.map { GameReport.wineTail($0, limit: limit) }+ let candidate = try encoder.encode(trimmed)+ if candidate.count <= Self.maximumEncodedSize {+ result = candidate+ lower = limit + 1+ } else {+ upper = limit - 1+ }+ }+ return result+ }static func make(name: String, appID: String, status: ReportStatus, source: Source, session: GameSession,log: String?, wineLog: String?, machine: GameReport.Machine, install: String,@@ -74,13 +106,20 @@ struct ReportSender: Sendable {}func submit(_ payload: ReportPayload) async -> Outcome {+ let body: Data+ do {+ body = try payload.encoded()+ } catch {+ AppLog.note("play report: could not encode the report: \(error.localizedDescription)")+ return .dropped+ }let file = queue.appending(path: "\(payload.appid)-\(UUID().uuidString).json")do {try FileManager.default.createDirectory(at: queue, withIntermediateDirectories: true)- try JSONEncoder().encode(payload).write(to: file, options: .atomic)+ try body.write(to: file, options: .atomic)} catch {AppLog.note("play report: could not queue the report: \(error.localizedDescription)")- return await post(try? JSONEncoder().encode(payload))+ return await post(body)}return await send(file)}@@ -108,7 +147,12 @@ struct ReportSender: Sendable {}private func post(_ body: Data?) async -> Outcome {- guard let body else { return .dropped }+ guard var body else { return .dropped }+ if body.count > ReportPayload.maximumEncodedSize {+ guard let payload = try? JSONDecoder().decode(ReportPayload.self, from: body),+ let bounded = try? payload.encoded() else { return .dropped }+ body = bounded+ }var request = URLRequest(url: endpoint, timeoutInterval: 30)request.httpMethod = "POST"request.setValue("application/json", forHTTPHeaderField: "Content-Type")diff --git a/app/Tests/BridgeplayAppTests/ReportPayloadSizeTests.swift b/app/Tests/BridgeplayAppTests/ReportPayloadSizeTests.swiftnew file mode 100644index 0000000..75f084e--- /dev/null+++ b/app/Tests/BridgeplayAppTests/ReportPayloadSizeTests.swift@@ -0,0 +1,119 @@+import Foundation+import Testing++@testable import BridgeplayApp++@Suite("Report uploads fit the endpoint's byte limit")+struct ReportPayloadSizeTests {+ private func payload(log: String?, wineLog: String?) -> ReportPayload {+ let machine = GameReport.Machine(chip: "Apple M1", memoryBytes: 8 * 1_073_741_824,+ macOS: "macOS 27.0", bridgeplay: "0.7.51")+ return ReportPayload.make(name: "Fixture Game", appID: "123", status: .borked, source: .tap,+ session: .byHand(), log: log, wineLog: wineLog, machine: machine,+ install: "fixture-install", note: "Game crashed")+ }++ @Test("Small reports keep their original encoding")+ func smallReport() throws {+ let report = payload(log: "recent run\n", wineLog: nil)+ let decoded = try JSONDecoder().decode(ReportPayload.self, from: report.encoded())+ #expect(decoded == report)+ }++ @Test("Unicode and JSON escapes fit with recent logs and earlier crash details", arguments: ["界", "\\", "\u{1}", "👨👩👧👦"])+ func boundedLogs(unit: String) throws {+ let filler = String(repeating: unit, count: unit.utf8.count > 4 ? 30_000 : 300_000)+ let error = "wine: could not load missing.dll\n"+ let report = payload(log: "SteamUser=private_player\n" + filler + "\nnewest run line\n",+ wineLog: error + filler + "\nnewest Wine line\n")+ #expect(report.log?.contains("private_player") == false, "redacted before trimming, not by it")+ #expect(try JSONEncoder().encode(report).count > ReportPayload.maximumEncodedSize)+ let body = try report.encoded()+ let sent = try JSONDecoder().decode(ReportPayload.self, from: body)+ #expect(body.count <= ReportPayload.maximumEncodedSize)+ #expect(sent.log?.hasSuffix("newest run line\n") == true)+ #expect(sent.wineLog?.hasSuffix("newest Wine line\n") == true)+ #expect(sent.wineLog?.contains(error) == true)+ #expect(sent.log?.contains("private_player") == false)+ #expect(sent.name == report.name && sent.note == report.note && sent.status == report.status)+ }++ @Test("An oversized Wine log fits without a run log")+ func wineOnly() throws {+ var oversized = payload(log: nil, wineLog: nil)+ oversized.wineLog = String(repeating: "界", count: 600_000) + "last Wine line\n"+ let body = try oversized.encoded()+ let sent = try JSONDecoder().decode(ReportPayload.self, from: body)+ #expect(body.count <= ReportPayload.maximumEncodedSize)+ #expect(sent.log == nil)+ #expect(sent.wineLog?.hasSuffix("last Wine line\n") == true)+ }++ @Test("Oversized metadata cannot produce an oversized upload")+ func oversizedMetadata() throws {+ var report = payload(log: nil, wineLog: nil)+ report.name = String(repeating: "x", count: ReportPayload.maximumEncodedSize + 1)+ #expect(throws: EncodingError.self) { try report.encoded() }+ }++ @Test("Offline reports are bounded before they enter the queue")+ func queuedReport() async throws {+ let queue = try scratchDirectory("report-size")+ defer { try? FileManager.default.removeItem(at: queue) }+ let report = payload(log: String(repeating: "界", count: 400_000), wineLog: nil)+ #expect(await FakeEndpoint.sender("offline", queue: queue).submit(report) == .retryLater)+ let files = try FileManager.default.contentsOfDirectory(at: queue, includingPropertiesForKeys: nil)+ let file = try #require(files.first)+ let body = try Data(contentsOf: file)+ #expect(files.count == 1)+ #expect(body.count <= ReportPayload.maximumEncodedSize)+ #expect(try JSONDecoder().decode(ReportPayload.self, from: body).appid == report.appid)+ }++ @Test("A size-limited endpoint accepts a new report and an older oversized queued report")+ func endpointAndLegacyQueue() async throws {+ let queue = try scratchDirectory("report-size")+ defer { try? FileManager.default.removeItem(at: queue) }+ let config = URLSessionConfiguration.ephemeral+ config.protocolClasses = [SizeLimitedReportEndpoint.self]+ let sender = ReportSender(endpoint: URL(string: "https://report-size.invalid/upload")!, queue: queue,+ session: URLSession(configuration: config))+ let report = payload(log: String(repeating: "界", count: 400_000), wineLog: nil)+ let original = try JSONEncoder().encode(report)+ #expect(original.count > ReportPayload.maximumEncodedSize)+ var request = URLRequest(url: sender.endpoint)+ request.httpMethod = "POST"+ request.httpBody = original+ let (_, response) = try await sender.session.data(for: request)+ #expect((response as? HTTPURLResponse)?.statusCode == 413)+ #expect(await sender.submit(report) == .sent)+ let old = queue.appending(path: "older-report.json")+ try original.write(to: old)+ await sender.retryPending(now: Date().addingTimeInterval(16 * 60))+ #expect(try FileManager.default.contentsOfDirectory(atPath: queue.path).isEmpty)+ }+}++private final class SizeLimitedReportEndpoint: URLProtocol, @unchecked Sendable {+ override class func canInit(with request: URLRequest) -> Bool { request.url?.host == "report-size.invalid" }+ override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }+ override func stopLoading() {}++ override func startLoading() {+ var bytes = request.httpBody?.count ?? 0+ if let stream = request.httpBodyStream {+ stream.open()+ defer { stream.close() }+ var buffer = [UInt8](repeating: 0, count: 8192)+ while stream.hasBytesAvailable {+ let count = stream.read(&buffer, maxLength: buffer.count)+ guard count > 0 else { break }+ bytes += count+ }+ }+ let status = bytes == 0 ? 400 : bytes > ReportPayload.maximumEncodedSize ? 413 : 201+ let response = HTTPURLResponse(url: request.url!, statusCode: status, httpVersion: nil, headerFields: nil)!+ client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)+ client?.urlProtocolDidFinishLoading(self)+ }+}