Skip to content

Free fork of NotProton: Windows Steam games in Mac Steam, on CodeWeavers' Wine and Apple's Game Porting Toolkit

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.swift
index 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_000
static 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.swift
new file mode 100644
index 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)
+ }
+}