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
108
109
110
111
112
|
//
// RelayCacheIO.swift
// RelayCacheIO
//
// Created by pronebird on 27/07/2021.
// Copyright © 2021 Mullvad VPN AB. All rights reserved.
//
import Foundation
extension RelayCache {
enum IO {}
}
extension RelayCache.IO {
/// The default cache file location bound by app group container.
static func defaultCacheFileURL(forSecurityApplicationGroupIdentifier appGroupIdentifier: String) -> URL? {
let containerURL = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: appGroupIdentifier)
return containerURL?.appendingPathComponent("relays.json")
}
/// The path to pre-bundled `relays.json` file.
static var preBundledRelaysFileURL: URL? {
return Bundle.main.url(forResource: "relays", withExtension: "json")
}
/// Safely read the cache file from disk using file coordinator.
static func read(cacheFileURL: URL) -> Result<RelayCache.CachedRelays, RelayCache.Error> {
var result: Result<RelayCache.CachedRelays, RelayCache.Error>?
let fileCoordinator = NSFileCoordinator(filePresenter: nil)
let accessor = { (fileURLForReading: URL) -> Void in
// Decode data from disk
result = Result { try Data(contentsOf: fileURLForReading) }
.mapError { RelayCache.Error.readCache($0) }
.flatMap { (data) in
Result { try JSONDecoder().decode(RelayCache.CachedRelays.self, from: data) }
.mapError { RelayCache.Error.decodeCache($0) }
}
}
var error: NSError?
fileCoordinator.coordinate(readingItemAt: cacheFileURL,
options: [.withoutChanges],
error: &error,
byAccessor: accessor)
if let error = error {
result = .failure(.readCache(error))
}
return result!
}
/// Safely read the cache file from disk using file coordinator and fallback to prebundled relays in case if the
/// relay cache file is missing.
static func readWithFallback(cacheFileURL: URL, preBundledRelaysFileURL: URL) -> Result<RelayCache.CachedRelays, RelayCache.Error> {
return Self.read(cacheFileURL: cacheFileURL)
.flatMapError { (error) -> Result<RelayCache.CachedRelays, RelayCache.Error> in
switch error {
case .decodeCache, .readCache(CocoaError.fileReadNoSuchFile):
return RelayCache.IO.readPrebundledRelays(fileURL: preBundledRelaysFileURL)
default:
return .failure(error)
}
}
}
/// Read pre-bundled relays file from disk.
static func readPrebundledRelays(fileURL: URL) -> Result<RelayCache.CachedRelays, RelayCache.Error> {
return Result { try Data(contentsOf: fileURL) }
.mapError { RelayCache.Error.readPrebundledRelays($0) }
.flatMap { (data) -> Result<RelayCache.CachedRelays, RelayCache.Error> in
return Result { try REST.Coding.makeJSONDecoder().decode(REST.ServerRelaysResponse.self, from: data) }
.mapError { RelayCache.Error.decodePrebundledRelays($0) }
.map { (relays) -> RelayCache.CachedRelays in
return RelayCache.CachedRelays(
relays: relays,
updatedAt: Date(timeIntervalSince1970: 0)
)
}
}
}
/// Safely write the cache file on disk using file coordinator.
static func write(cacheFileURL: URL, record: RelayCache.CachedRelays) -> Result<(), RelayCache.Error> {
var result: Result<(), RelayCache.Error>?
let fileCoordinator = NSFileCoordinator(filePresenter: nil)
let accessor = { (fileURLForWriting: URL) -> Void in
result = Result { try JSONEncoder().encode(record) }
.mapError { RelayCache.Error.encodeCache($0) }
.flatMap { (data) in
Result { try data.write(to: fileURLForWriting) }
.mapError { RelayCache.Error.writeCache($0) }
}
}
var error: NSError?
fileCoordinator.coordinate(writingItemAt: cacheFileURL,
options: [.forReplacing],
error: &error,
byAccessor: accessor)
if let error = error {
result = .failure(.writeCache(error))
}
return result!
}
}
|
