예산, 거절, 마감이 있는 URLSession

import Foundation

// Reading a 1 MiB body one byte at a time. Measured with Swift 6.3.3, -O, on macOS 26:
@MainActor
func readOnMainActor(_ url: URL) async throws -> Data {        // 0.1 MiB/s
    var out = Data()
    let (bytes, _) = try await URLSession.shared.bytes(from: url)
    for try await byte in bytes { out.append(byte) }           // every element is an await
    return out
}

@concurrent
func readOffTheMainActor(_ url: URL) async throws -> Data {    // 23.8 MiB/s
    var out = Data()
    let (bytes, _) = try await URLSession.shared.bytes(from: url)
    for try await byte in bytes { out.append(byte) }
    return out
}
// The chunked delegate below moved 8 MiB over loopback HTTP at about 1,500 MiB/s.

import Foundation

struct FetchReply: Sendable {
    let status: Int
    let body: Data
}

enum FetchFailure: Error, Equatable {
    case overBudget(limit: Int)
    case redirectRefused(status: Int)
    case transport(URLError.Code)
}

/// One request, read in chunks, cut off the moment the body would exceed its budget.
final class BudgetedFetch: NSObject, URLSessionDataDelegate, @unchecked Sendable {
    private let budget: Int
    private let lock = NSLock()
    private var body = Data()
    private var failure: FetchFailure?
    private var continuation: CheckedContinuation<FetchReply, Error>?

    init(budget: Int) { self.budget = budget }

    func run(_ request: URLRequest) async throws -> FetchReply {
        let configuration = URLSessionConfiguration.ephemeral
        configuration.httpCookieStorage = nil
        configuration.urlCache = nil
        configuration.timeoutIntervalForRequest = 15     // longest silence between bytes
        configuration.timeoutIntervalForResource = 300   // the whole exchange
        let session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
        defer { session.finishTasksAndInvalidate() }
        let task = session.dataTask(with: request)
        return try await withTaskCancellationHandler {
            try await withCheckedThrowingContinuation { continuation in
                lock.withLock { self.continuation = continuation }
                task.resume()
            }
        } onCancel: {
            task.cancel()
        }
    }

    // Passing nil stops at the 3xx instead of following it, and the fetch reports it as redirectRefused.
    // A configuration alone cannot refuse a redirect.
    func urlSession(_ session: URLSession, task: URLSessionTask,
                    willPerformHTTPRedirection response: HTTPURLResponse, newRequest request: URLRequest,
                    completionHandler: @escaping @Sendable (URLRequest?) -> Void) {
        lock.withLock { failure = .redirectRefused(status: response.statusCode) }
        completionHandler(nil)
    }

    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
        let over = lock.withLock {
            body.append(data)   // one append per chunk, never per byte
            guard body.count > budget else { return false }
            failure = .overBudget(limit: budget)
            return true
        }
        if over { dataTask.cancel() }
    }

    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
        let (waiting, result) = lock.withLock { () -> (CheckedContinuation<FetchReply, Error>?, Result<FetchReply, Error>) in
            defer { continuation = nil }
            if let failure { return (continuation, .failure(failure)) }
            if let error = error as? URLError { return (continuation, .failure(FetchFailure.transport(error.code))) }
            if let error { return (continuation, .failure(error)) }
            let status = (task.response as? HTTPURLResponse)?.statusCode ?? 0
            return (continuation, .success(FetchReply(status: status, body: body)))
        }
        waiting?.resume(with: result)
    }
}