blob: 378da0342561526d597442fa137fd448b0aee4cf (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
//
// RESTRustNetworkOperation.swift
// MullvadREST
//
// Created by Jon Petersson on 2025-01-29.
// Copyright © 2025 Mullvad VPN AB. All rights reserved.
//
import Foundation
import MullvadLogging
import MullvadRustRuntime
import MullvadTypes
import Operations
extension REST {
class MullvadApiNetworkOperation<Success: Sendable>: ResultOperation<Success>, @unchecked Sendable {
private let logger: Logger
private let requestHandler: MullvadApiRequestHandler
private var responseDecoder: JSONDecoder
private let responseHandler: any RESTRustResponseHandler<Success>
private var networkTask: MullvadApiCancellable?
init(
name: String,
dispatchQueue: DispatchQueue,
requestHandler: @escaping MullvadApiRequestHandler,
responseDecoder: JSONDecoder,
responseHandler: some RESTRustResponseHandler<Success>,
completionHandler: CompletionHandler? = nil
) {
self.responseDecoder = responseDecoder
self.requestHandler = requestHandler
self.responseHandler = responseHandler
var logger = Logger(label: "REST.RustNetworkOperation")
logger[metadataKey: "name"] = .string(name)
self.logger = logger
super.init(
dispatchQueue: dispatchQueue,
completionQueue: .main,
completionHandler: completionHandler
)
}
override public func operationDidCancel() {
networkTask?.cancel()
networkTask = nil
}
override public func main() {
startRequest()
}
func startRequest() {
dispatchPrecondition(condition: .onQueue(dispatchQueue))
guard !isCancelled else {
finish(result: .failure(OperationError.cancelled))
return
}
networkTask = requestHandler { [weak self] response in
guard let self else { return }
if let error = response.restError() {
finish(result: .failure(error))
return
}
let decodedResponse = responseHandler.handleResponse(response)
switch decodedResponse {
case let .success(value):
finish(result: .success(value))
case let .decoding(block):
finish(result: .success(try block()))
case let .unhandledResponse(error):
finish(result: .failure(REST.Error.unhandledResponse(Int(response.statusCode), error)))
}
}
}
}
}
extension MullvadApiResponse {
public func restError() -> REST.Error? {
guard !success else {
return nil
}
guard let serverResponseCode else {
return .transport(MullvadApiTransportError.connectionFailed(description: errorDescription))
}
let response = REST.ServerErrorResponse(
code: REST.ServerResponseCode(rawValue: serverResponseCode),
detail: errorDescription
)
return .unhandledResponse(Int(statusCode), response)
}
}
enum MullvadApiTransportError: Error {
case connectionFailed(description: String?)
}
|
