@gfean/react-native-bundle-drop 0.5.1 → 0.7.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/BundleDrop.podspec +96 -0
- package/README.md +194 -5
- package/android/build.gradle +66 -0
- package/android/src/main/java/com/bundledrop/BundleDropBoundedDownloader.kt +86 -0
- package/android/src/main/java/com/bundledrop/BundleDropModule.kt +206 -13
- package/android/src/main/java/com/bundledrop/BundleDropNativePaths.kt +43 -13
- package/android/src/main/java/com/bundledrop/BundleDropOtaResolver.kt +35 -0
- package/android/src/main/java/com/bundledrop/BundleDropRuntimeCrypto.kt +81 -0
- package/android/src/main/java/com/bundledrop/BundleDropStartupRecovery.kt +1117 -0
- package/ios/BundleDropBridge.m +45 -0
- package/ios/BundleDropLocator.swift +66 -4
- package/ios/BundleDropModule.swift +181 -3
- package/ios/BundleDropOtaResolver.swift +137 -29
- package/ios/BundleDropRuntimeCrypto.swift +45 -0
- package/ios/BundleDropStartupRecovery.swift +1108 -0
- package/ios/BundleDropStartupRecoveryAdapter.swift +301 -0
- package/lib/CLI/cli.d.ts +1 -0
- package/lib/CLI/cli.js +57 -6
- package/lib/CLI/scripts/aipowered/apply-setup-plan.js +7 -17
- package/lib/CLI/scripts/aipowered/backend-client.js +29 -4
- package/lib/CLI/scripts/aipowered/code-push-residue.d.ts +5 -0
- package/lib/CLI/scripts/aipowered/code-push-residue.js +126 -0
- package/lib/CLI/scripts/aipowered/credential-safety.d.ts +1 -0
- package/lib/CLI/scripts/aipowered/credential-safety.js +14 -0
- package/lib/CLI/scripts/aipowered/diff-preview.js +12 -4
- package/lib/CLI/scripts/aipowered/init-project-config.d.ts +4 -0
- package/lib/CLI/scripts/aipowered/init-project-config.js +221 -45
- package/lib/CLI/scripts/aipowered/scanner.d.ts +1 -0
- package/lib/CLI/scripts/aipowered/scanner.js +164 -32
- package/lib/CLI/scripts/aipowered/terminal-safety.d.ts +4 -0
- package/lib/CLI/scripts/aipowered/terminal-safety.js +124 -0
- package/lib/CLI/scripts/aipowered/validate-plan.d.ts +3 -0
- package/lib/CLI/scripts/aipowered/validate-plan.js +1080 -19
- package/lib/CLI/scripts/bare-metro-config.d.ts +1 -1
- package/lib/CLI/scripts/bare-metro-config.js +24 -32
- package/lib/CLI/scripts/doctor.js +162 -22
- package/lib/CLI/scripts/expo/configure-expo.js +52 -60
- package/lib/CLI/scripts/expo/package-manager.d.ts +2 -0
- package/lib/CLI/scripts/expo/package-manager.js +63 -25
- package/lib/CLI/scripts/init-config.d.ts +7 -7
- package/lib/CLI/scripts/init-config.js +198 -14
- package/lib/CLI/scripts/login-cli.js +31 -7
- package/lib/CLI/scripts/metro-config-authority.d.ts +8 -0
- package/lib/CLI/scripts/metro-config-authority.js +303 -0
- package/lib/CLI/scripts/native/write-runtime-identity.d.ts +19 -0
- package/lib/CLI/scripts/native/write-runtime-identity.js +92 -0
- package/lib/CLI/scripts/native-entrypoint-authority.d.ts +2 -0
- package/lib/CLI/scripts/native-entrypoint-authority.js +378 -0
- package/lib/CLI/scripts/native-setup-contract.d.ts +2 -2
- package/lib/CLI/scripts/native-setup-contract.js +63 -33
- package/lib/CLI/scripts/native-startup-validator.d.ts +3 -0
- package/lib/CLI/scripts/native-startup-validator.js +964 -0
- package/lib/CLI/scripts/safe-file-transaction.d.ts +12 -0
- package/lib/CLI/scripts/safe-file-transaction.js +159 -0
- package/lib/CLI/scripts/upload-cli.d.ts +12 -2
- package/lib/CLI/scripts/upload-cli.js +74 -11
- package/lib/CLI/serverUrl.d.ts +3 -0
- package/lib/CLI/serverUrl.js +31 -0
- package/lib/api/clientApi.d.ts +3 -1
- package/lib/api/clientApi.js +14 -0
- package/lib/api/types.d.ts +39 -0
- package/lib/bundleInfo.d.ts +2 -0
- package/lib/bundleInfo.js +16 -1
- package/lib/context.d.ts +1 -1
- package/lib/context.js +12 -2
- package/lib/fs/bundlePointer.d.ts +1 -17
- package/lib/fs/bundlePointer.js +5 -93
- package/lib/index.d.ts +2 -0
- package/lib/index.js +3 -1
- package/lib/install/bundleInstallShared.js +4 -4
- package/lib/install/installFromZip.d.ts +3 -0
- package/lib/install/installFromZip.js +10 -1
- package/lib/loadConfig.d.ts +17 -1
- package/lib/loadConfig.js +16 -0
- package/lib/manager/downloadAndInstall.d.ts +3 -2
- package/lib/manager/downloadAndInstall.js +134 -66
- package/lib/manager/reporting.d.ts +8 -1
- package/lib/manager/reporting.js +17 -22
- package/lib/manager/rollbackState.d.ts +18 -52
- package/lib/manager/rollbackState.js +115 -216
- package/lib/manager/updateCheck.d.ts +1 -0
- package/lib/manager/updateCheck.js +224 -78
- package/lib/manager/updateState.d.ts +2 -1
- package/lib/manager/updateState.js +59 -6
- package/lib/metro.d.ts +8 -1
- package/lib/metro.js +69 -19
- package/lib/native/bundleDropNative.d.ts +62 -0
- package/lib/native/bundleDropNative.js +268 -2
- package/lib/native/fs.d.ts +6 -0
- package/lib/native/fs.js +24 -0
- package/lib/patch-engine/installFromPatchSet.d.ts +2 -0
- package/lib/patch-engine/installFromPatchSet.js +16 -5
- package/lib/patch-engine/patchTransport.d.ts +2 -0
- package/lib/patch-engine/patchTransport.js +9 -0
- package/lib/runtime/initState.d.ts +5 -0
- package/lib/runtime/initState.js +4 -0
- package/lib/runtime/service.js +82 -67
- package/lib/runtime-delivery/artifactCapability.d.ts +1 -0
- package/lib/runtime-delivery/artifactCapability.js +32 -0
- package/lib/runtime-delivery/authorityLeaseVerifier.d.ts +3 -0
- package/lib/runtime-delivery/authorityLeaseVerifier.js +106 -0
- package/lib/runtime-delivery/bootstrapConfig.d.ts +68 -0
- package/lib/runtime-delivery/bootstrapConfig.js +278 -0
- package/lib/runtime-delivery/diagnostics.d.ts +17 -0
- package/lib/runtime-delivery/diagnostics.js +58 -0
- package/lib/runtime-delivery/encoding.d.ts +5 -0
- package/lib/runtime-delivery/encoding.js +132 -0
- package/lib/runtime-delivery/heartbeat.d.ts +3 -0
- package/lib/runtime-delivery/heartbeat.js +88 -0
- package/lib/runtime-delivery/localResolver.d.ts +23 -0
- package/lib/runtime-delivery/localResolver.js +81 -0
- package/lib/runtime-delivery/manifestState.d.ts +11 -0
- package/lib/runtime-delivery/manifestState.js +123 -0
- package/lib/runtime-delivery/manifestVerifier.d.ts +13 -0
- package/lib/runtime-delivery/manifestVerifier.js +335 -0
- package/lib/runtime-delivery/runtimeDelivery.d.ts +19 -0
- package/lib/runtime-delivery/runtimeDelivery.js +375 -0
- package/lib/runtime-delivery/types.d.ts +87 -0
- package/lib/runtime-delivery/types.js +6 -0
- package/lib/scripts/bundle.d.ts +9 -2
- package/lib/scripts/bundle.js +68 -18
- package/lib/scripts/download-bundle.d.ts +1 -0
- package/lib/scripts/download-bundle.js +2 -2
- package/lib/scripts/resolveModule.d.ts +2 -0
- package/lib/scripts/resolveModule.js +5 -0
- package/package.json +5 -2
- package/plugin/xcodeBuildPhase.js +2 -1
|
@@ -0,0 +1,1108 @@
|
|
|
1
|
+
import Foundation
|
|
2
|
+
|
|
3
|
+
enum BundleDropStartupRecoveryError: LocalizedError {
|
|
4
|
+
case invalidHash
|
|
5
|
+
case invalidHealthCheckMode
|
|
6
|
+
case invalidPolicy
|
|
7
|
+
case candidateUnavailable
|
|
8
|
+
case candidateIneligible
|
|
9
|
+
case ledgerCorrupt
|
|
10
|
+
case storageUnavailable
|
|
11
|
+
case staleLedger
|
|
12
|
+
|
|
13
|
+
var errorDescription: String? {
|
|
14
|
+
switch self {
|
|
15
|
+
case .invalidHash:
|
|
16
|
+
return "Bundle Drop startup recovery received an invalid bundle hash"
|
|
17
|
+
case .invalidHealthCheckMode:
|
|
18
|
+
return "Bundle Drop startup recovery healthCheckMode must be auto or manual"
|
|
19
|
+
case .invalidPolicy:
|
|
20
|
+
return "Bundle Drop startup recovery policy must use a non-negative 32-bit integer maxCrashCount and a finite non-negative healthyAfterSec"
|
|
21
|
+
case .candidateUnavailable:
|
|
22
|
+
return "Bundle Drop startup recovery could not verify the candidate bundle"
|
|
23
|
+
case .candidateIneligible:
|
|
24
|
+
return "Bundle Drop startup recovery rejected a quarantined or revoked candidate"
|
|
25
|
+
case .ledgerCorrupt:
|
|
26
|
+
return "Bundle Drop startup recovery ledger is malformed or unsupported"
|
|
27
|
+
case .storageUnavailable:
|
|
28
|
+
return "Bundle Drop startup recovery storage is unavailable"
|
|
29
|
+
case .staleLedger:
|
|
30
|
+
return "Bundle Drop startup recovery rejected a stale ledger transition"
|
|
31
|
+
}
|
|
32
|
+
}
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
enum BundleDropStartupRecoveryPhase: String, Codable {
|
|
36
|
+
case idle
|
|
37
|
+
case armed
|
|
38
|
+
case launching
|
|
39
|
+
case stable
|
|
40
|
+
case recovered
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
struct BundleDropStartupRecoveryPolicy: Codable, Equatable {
|
|
44
|
+
let maxCrashCount: Int
|
|
45
|
+
let healthCheckMode: String
|
|
46
|
+
let healthyAfterSec: Double
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
struct BundleDropStartupRecoveryAttempt: Codable, Equatable {
|
|
50
|
+
let hash: String
|
|
51
|
+
let attemptId: String
|
|
52
|
+
let processToken: String
|
|
53
|
+
let startedAt: Int64
|
|
54
|
+
var unacknowledgedLaunchCount: Int
|
|
55
|
+
var contentAppeared: Bool
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
struct BundleDropStartupRecoveryTransition: Codable, Equatable {
|
|
59
|
+
let kind: String
|
|
60
|
+
let targetHash: String?
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
struct BundleDropStartupRecoveryEvent: Codable, Equatable {
|
|
64
|
+
let id: String
|
|
65
|
+
let failedHash: String
|
|
66
|
+
let recoveryTarget: String
|
|
67
|
+
let recoveredHash: String?
|
|
68
|
+
let crashCount: Int
|
|
69
|
+
let reason: String
|
|
70
|
+
let failedAt: Int64
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
struct BundleDropStartupRecoveryLedger: Codable, Equatable {
|
|
74
|
+
var schemaVersion = 1
|
|
75
|
+
var revision = 0
|
|
76
|
+
var binaryIdentity: String?
|
|
77
|
+
var runtimeIdentity: String?
|
|
78
|
+
var legacyFailuresImported: Bool?
|
|
79
|
+
var phase = BundleDropStartupRecoveryPhase.idle
|
|
80
|
+
var candidateHash: String?
|
|
81
|
+
var stableHash: String?
|
|
82
|
+
var previousStableHash: String?
|
|
83
|
+
var lastHealthyAttemptId: String?
|
|
84
|
+
var activeAttempt: BundleDropStartupRecoveryAttempt?
|
|
85
|
+
var reservedAttemptId: String?
|
|
86
|
+
var pendingTransition: BundleDropStartupRecoveryTransition?
|
|
87
|
+
var policy: BundleDropStartupRecoveryPolicy?
|
|
88
|
+
var quarantinedHashes: [String] = []
|
|
89
|
+
var revokedHashes: [String] = []
|
|
90
|
+
var pendingRecoveryEvents: [BundleDropStartupRecoveryEvent] = []
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
struct BundleDropStartupSelection: Equatable {
|
|
94
|
+
let bundleURL: URL?
|
|
95
|
+
let attemptHash: String?
|
|
96
|
+
let attemptId: String?
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
struct BundleDropStartupActivationResult: Equatable {
|
|
100
|
+
let hash: String
|
|
101
|
+
let bundleURL: URL
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
struct BundleDropStartupRollbackResult: Equatable {
|
|
105
|
+
let rolledBack: Bool
|
|
106
|
+
let toEmbedded: Bool
|
|
107
|
+
let hash: String?
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
/// Native-owned startup ledger. JavaScript may request transitions through the bridge,
|
|
111
|
+
/// but it never writes this file directly.
|
|
112
|
+
final class BundleDropStartupRecoveryController {
|
|
113
|
+
static let protocolVersion = 1
|
|
114
|
+
private static let ledgerCommitLock = NSLock()
|
|
115
|
+
|
|
116
|
+
typealias Failpoint = (String) throws -> Void
|
|
117
|
+
|
|
118
|
+
private let bundleDropRoot: URL
|
|
119
|
+
private let expectedRuntimeVersion: String?
|
|
120
|
+
private let expectedBinaryIdentity: String?
|
|
121
|
+
private let processToken: String
|
|
122
|
+
private let fileManager: FileManager
|
|
123
|
+
private let now: () -> Int64
|
|
124
|
+
private let makeId: () -> String
|
|
125
|
+
private let failpoint: Failpoint?
|
|
126
|
+
private let lock = NSRecursiveLock()
|
|
127
|
+
|
|
128
|
+
private var ledgerURL: URL {
|
|
129
|
+
bundleDropRoot.appendingPathComponent("recovery-ledger.json")
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
private var legacyStateURL: URL {
|
|
133
|
+
bundleDropRoot.appendingPathComponent("state.json")
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
init(
|
|
137
|
+
bundleDropRoot: URL,
|
|
138
|
+
expectedRuntimeVersion: String?,
|
|
139
|
+
expectedBinaryIdentity: String? = nil,
|
|
140
|
+
processToken: String = UUID().uuidString.lowercased(),
|
|
141
|
+
fileManager: FileManager = .default,
|
|
142
|
+
now: @escaping () -> Int64 = { Int64(Date().timeIntervalSince1970) },
|
|
143
|
+
makeId: @escaping () -> String = { UUID().uuidString.lowercased() },
|
|
144
|
+
failpoint: Failpoint? = nil
|
|
145
|
+
) {
|
|
146
|
+
self.bundleDropRoot = bundleDropRoot
|
|
147
|
+
self.expectedRuntimeVersion = expectedRuntimeVersion
|
|
148
|
+
self.expectedBinaryIdentity = expectedBinaryIdentity
|
|
149
|
+
self.processToken = processToken
|
|
150
|
+
self.fileManager = fileManager
|
|
151
|
+
self.now = now
|
|
152
|
+
self.makeId = makeId
|
|
153
|
+
self.failpoint = failpoint
|
|
154
|
+
}
|
|
155
|
+
|
|
156
|
+
func activateCandidate(
|
|
157
|
+
hash: String,
|
|
158
|
+
maxCrashCount: Int,
|
|
159
|
+
healthCheckMode: String,
|
|
160
|
+
healthyAfterSec: Double
|
|
161
|
+
) throws -> BundleDropStartupActivationResult {
|
|
162
|
+
try withLock {
|
|
163
|
+
guard hasExpectedIdentity else {
|
|
164
|
+
throw BundleDropStartupRecoveryError.candidateUnavailable
|
|
165
|
+
}
|
|
166
|
+
guard Self.isCanonicalHash(hash) else {
|
|
167
|
+
throw BundleDropStartupRecoveryError.invalidHash
|
|
168
|
+
}
|
|
169
|
+
guard healthCheckMode == "auto" || healthCheckMode == "manual" else {
|
|
170
|
+
throw BundleDropStartupRecoveryError.invalidHealthCheckMode
|
|
171
|
+
}
|
|
172
|
+
guard maxCrashCount >= 0,
|
|
173
|
+
maxCrashCount <= Int(Int32.max),
|
|
174
|
+
healthyAfterSec.isFinite,
|
|
175
|
+
healthyAfterSec >= 0 else {
|
|
176
|
+
throw BundleDropStartupRecoveryError.invalidPolicy
|
|
177
|
+
}
|
|
178
|
+
guard let candidate = BundleDropOtaResolver.readBundle(
|
|
179
|
+
hash: hash,
|
|
180
|
+
bundleDropRoot: bundleDropRoot,
|
|
181
|
+
expectedRuntimeVersion: expectedRuntimeVersion,
|
|
182
|
+
fileManager: fileManager
|
|
183
|
+
) else {
|
|
184
|
+
throw BundleDropStartupRecoveryError.candidateUnavailable
|
|
185
|
+
}
|
|
186
|
+
try failpoint?("afterCandidateVerified")
|
|
187
|
+
|
|
188
|
+
var ledger = try readLedgerImportingLegacyState()
|
|
189
|
+
if ledger.pendingTransition != nil {
|
|
190
|
+
try completePendingTransition(ledger: &ledger)
|
|
191
|
+
}
|
|
192
|
+
guard !ledger.quarantinedHashes.contains(hash), !ledger.revokedHashes.contains(hash) else {
|
|
193
|
+
throw BundleDropStartupRecoveryError.candidateIneligible
|
|
194
|
+
}
|
|
195
|
+
|
|
196
|
+
let current = BundleDropOtaResolver.readPointer(
|
|
197
|
+
named: "current.json",
|
|
198
|
+
bundleDropRoot: bundleDropRoot,
|
|
199
|
+
expectedRuntimeVersion: expectedRuntimeVersion,
|
|
200
|
+
fileManager: fileManager
|
|
201
|
+
)
|
|
202
|
+
let requestedPolicy = BundleDropStartupRecoveryPolicy(
|
|
203
|
+
maxCrashCount: maxCrashCount,
|
|
204
|
+
healthCheckMode: healthCheckMode,
|
|
205
|
+
healthyAfterSec: healthyAfterSec
|
|
206
|
+
)
|
|
207
|
+
if current?.hash == hash,
|
|
208
|
+
ledger.stableHash == hash,
|
|
209
|
+
ledger.phase == .stable || ledger.phase == .recovered {
|
|
210
|
+
return BundleDropStartupActivationResult(hash: hash, bundleURL: candidate.bundleURL)
|
|
211
|
+
}
|
|
212
|
+
if current?.hash == hash,
|
|
213
|
+
ledger.candidateHash == hash,
|
|
214
|
+
ledger.phase == .armed || ledger.phase == .launching {
|
|
215
|
+
var changed = ledger.policy != requestedPolicy
|
|
216
|
+
ledger.policy = requestedPolicy
|
|
217
|
+
if requestedPolicy.maxCrashCount == 0 {
|
|
218
|
+
changed = changed || ledger.phase != .armed || ledger.activeAttempt != nil || ledger.reservedAttemptId != nil
|
|
219
|
+
ledger.phase = .armed
|
|
220
|
+
ledger.activeAttempt = nil
|
|
221
|
+
ledger.reservedAttemptId = nil
|
|
222
|
+
ledger.lastHealthyAttemptId = nil
|
|
223
|
+
} else if ledger.phase == .armed, ledger.reservedAttemptId == nil {
|
|
224
|
+
ledger.reservedAttemptId = makeId()
|
|
225
|
+
changed = true
|
|
226
|
+
}
|
|
227
|
+
if changed {
|
|
228
|
+
try commit(&ledger)
|
|
229
|
+
}
|
|
230
|
+
return BundleDropStartupActivationResult(hash: hash, bundleURL: candidate.bundleURL)
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
let previousPointer = BundleDropOtaResolver.readPointer(
|
|
234
|
+
named: "previous.json",
|
|
235
|
+
bundleDropRoot: bundleDropRoot,
|
|
236
|
+
expectedRuntimeVersion: expectedRuntimeVersion,
|
|
237
|
+
fileManager: fileManager
|
|
238
|
+
)
|
|
239
|
+
let currentIsProvenStable = current?.hash == ledger.stableHash
|
|
240
|
+
let previousIsProvenStable = previousPointer?.hash == ledger.stableHash
|
|
241
|
+
let fallbackHash: String?
|
|
242
|
+
if currentIsProvenStable, let currentHash = current?.hash {
|
|
243
|
+
fallbackHash = currentHash
|
|
244
|
+
try writePointer(named: "previous.json", hash: currentHash, failpointPrefix: "previous")
|
|
245
|
+
} else if current?.hash == hash && previousIsProvenStable {
|
|
246
|
+
// Transitional compatibility for a JS client that changed current.json first.
|
|
247
|
+
fallbackHash = previousPointer?.hash
|
|
248
|
+
} else {
|
|
249
|
+
fallbackHash = nil
|
|
250
|
+
try? BundleDropOtaResolver.deletePointer(
|
|
251
|
+
named: "previous.json",
|
|
252
|
+
bundleDropRoot: bundleDropRoot,
|
|
253
|
+
fileManager: fileManager
|
|
254
|
+
)
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
ledger.phase = .armed
|
|
258
|
+
ledger.candidateHash = hash
|
|
259
|
+
ledger.stableHash = fallbackHash
|
|
260
|
+
ledger.previousStableHash = nil
|
|
261
|
+
ledger.lastHealthyAttemptId = nil
|
|
262
|
+
ledger.activeAttempt = nil
|
|
263
|
+
ledger.policy = requestedPolicy
|
|
264
|
+
ledger.reservedAttemptId = requestedPolicy.maxCrashCount > 0 ? makeId() : nil
|
|
265
|
+
try commit(&ledger)
|
|
266
|
+
try failpoint?("afterCandidateArmed")
|
|
267
|
+
|
|
268
|
+
if current?.hash != hash {
|
|
269
|
+
try writePointer(named: "current.json", hash: hash, failpointPrefix: "current")
|
|
270
|
+
}
|
|
271
|
+
return BundleDropStartupActivationResult(hash: hash, bundleURL: candidate.bundleURL)
|
|
272
|
+
}
|
|
273
|
+
}
|
|
274
|
+
|
|
275
|
+
func selectStartupBundle(beginReload: Bool = false) -> BundleDropStartupSelection {
|
|
276
|
+
withLock {
|
|
277
|
+
guard hasExpectedIdentity else {
|
|
278
|
+
return BundleDropStartupSelection(bundleURL: nil, attemptHash: nil, attemptId: nil)
|
|
279
|
+
}
|
|
280
|
+
do {
|
|
281
|
+
var ledger = try readLedgerImportingLegacyState()
|
|
282
|
+
if ledger.pendingTransition != nil {
|
|
283
|
+
try completePendingTransition(ledger: &ledger)
|
|
284
|
+
}
|
|
285
|
+
guard let current = BundleDropOtaResolver.readPointer(
|
|
286
|
+
named: "current.json",
|
|
287
|
+
bundleDropRoot: bundleDropRoot,
|
|
288
|
+
expectedRuntimeVersion: expectedRuntimeVersion,
|
|
289
|
+
fileManager: fileManager
|
|
290
|
+
) else {
|
|
291
|
+
if ledger.phase == .armed {
|
|
292
|
+
let fallback = ledger.stableHash.flatMap { hash in
|
|
293
|
+
verifiedPreviousPointer(hash: hash, ledger: ledger)
|
|
294
|
+
}
|
|
295
|
+
if let fallback {
|
|
296
|
+
try writePointer(
|
|
297
|
+
named: "current.json",
|
|
298
|
+
hash: fallback.hash,
|
|
299
|
+
failpointPrefix: "abortedActivationCurrent"
|
|
300
|
+
)
|
|
301
|
+
}
|
|
302
|
+
ledger.phase = fallback == nil ? .idle : .stable
|
|
303
|
+
ledger.candidateHash = nil
|
|
304
|
+
ledger.stableHash = fallback?.hash
|
|
305
|
+
ledger.previousStableHash = nil
|
|
306
|
+
ledger.activeAttempt = nil
|
|
307
|
+
ledger.reservedAttemptId = nil
|
|
308
|
+
ledger.policy = nil
|
|
309
|
+
try? BundleDropOtaResolver.deletePointer(
|
|
310
|
+
named: "previous.json",
|
|
311
|
+
bundleDropRoot: bundleDropRoot,
|
|
312
|
+
fileManager: fileManager
|
|
313
|
+
)
|
|
314
|
+
try commit(&ledger)
|
|
315
|
+
return BundleDropStartupSelection(
|
|
316
|
+
bundleURL: fallback?.bundleURL,
|
|
317
|
+
attemptHash: nil,
|
|
318
|
+
attemptId: nil
|
|
319
|
+
)
|
|
320
|
+
}
|
|
321
|
+
return BundleDropStartupSelection(bundleURL: nil, attemptHash: nil, attemptId: nil)
|
|
322
|
+
}
|
|
323
|
+
|
|
324
|
+
// Activation writes the ledger before publishing current.json. If the
|
|
325
|
+
// process stops between those writes, abandon the unpublished candidate
|
|
326
|
+
// and continue booting the previously proven bundle.
|
|
327
|
+
if ledger.phase == .armed,
|
|
328
|
+
ledger.candidateHash != current.hash,
|
|
329
|
+
ledger.stableHash == current.hash {
|
|
330
|
+
ledger.phase = .stable
|
|
331
|
+
ledger.candidateHash = nil
|
|
332
|
+
ledger.activeAttempt = nil
|
|
333
|
+
ledger.reservedAttemptId = nil
|
|
334
|
+
ledger.policy = nil
|
|
335
|
+
try? BundleDropOtaResolver.deletePointer(
|
|
336
|
+
named: "previous.json",
|
|
337
|
+
bundleDropRoot: bundleDropRoot,
|
|
338
|
+
fileManager: fileManager
|
|
339
|
+
)
|
|
340
|
+
try commit(&ledger)
|
|
341
|
+
return BundleDropStartupSelection(bundleURL: current.bundleURL, attemptHash: nil, attemptId: nil)
|
|
342
|
+
}
|
|
343
|
+
|
|
344
|
+
if ledger.revokedHashes.contains(current.hash) || ledger.quarantinedHashes.contains(current.hash) {
|
|
345
|
+
return try recover(
|
|
346
|
+
failedHash: current.hash,
|
|
347
|
+
crashCount: ledger.activeAttempt?.unacknowledgedLaunchCount ?? 0,
|
|
348
|
+
quarantine: ledger.quarantinedHashes.contains(current.hash),
|
|
349
|
+
emitEvent: false,
|
|
350
|
+
ledger: &ledger
|
|
351
|
+
)
|
|
352
|
+
}
|
|
353
|
+
|
|
354
|
+
if ledger.stableHash == current.hash,
|
|
355
|
+
ledger.phase == .stable || ledger.phase == .recovered {
|
|
356
|
+
return BundleDropStartupSelection(
|
|
357
|
+
bundleURL: current.bundleURL,
|
|
358
|
+
attemptHash: nil,
|
|
359
|
+
attemptId: nil
|
|
360
|
+
)
|
|
361
|
+
}
|
|
362
|
+
|
|
363
|
+
guard ledger.candidateHash == current.hash,
|
|
364
|
+
ledger.phase == .armed || ledger.phase == .launching,
|
|
365
|
+
let policy = ledger.policy else {
|
|
366
|
+
// An OTA without native proof must never become startup-visible.
|
|
367
|
+
try BundleDropOtaResolver.deletePointer(
|
|
368
|
+
named: "current.json",
|
|
369
|
+
bundleDropRoot: bundleDropRoot,
|
|
370
|
+
fileManager: fileManager
|
|
371
|
+
)
|
|
372
|
+
return BundleDropStartupSelection(bundleURL: nil, attemptHash: nil, attemptId: nil)
|
|
373
|
+
}
|
|
374
|
+
|
|
375
|
+
// A zero limit explicitly disables launch-health classification. The
|
|
376
|
+
// candidate remains ledger-tracked for integrity and revocation checks,
|
|
377
|
+
// but it is never treated as health-proven or charged a failed attempt.
|
|
378
|
+
if policy.maxCrashCount == 0 {
|
|
379
|
+
return BundleDropStartupSelection(
|
|
380
|
+
bundleURL: current.bundleURL,
|
|
381
|
+
attemptHash: nil,
|
|
382
|
+
attemptId: nil
|
|
383
|
+
)
|
|
384
|
+
}
|
|
385
|
+
|
|
386
|
+
if !beginReload,
|
|
387
|
+
ledger.activeAttempt?.processToken == processToken,
|
|
388
|
+
ledger.activeAttempt?.hash == current.hash {
|
|
389
|
+
return BundleDropStartupSelection(
|
|
390
|
+
bundleURL: current.bundleURL,
|
|
391
|
+
attemptHash: current.hash,
|
|
392
|
+
attemptId: ledger.activeAttempt?.attemptId
|
|
393
|
+
)
|
|
394
|
+
}
|
|
395
|
+
|
|
396
|
+
var unacknowledgedLaunchCount = ledger.activeAttempt?.unacknowledgedLaunchCount ?? 0
|
|
397
|
+
if ledger.phase == .launching, !beginReload {
|
|
398
|
+
unacknowledgedLaunchCount += 1
|
|
399
|
+
}
|
|
400
|
+
|
|
401
|
+
if policy.maxCrashCount > 0,
|
|
402
|
+
unacknowledgedLaunchCount >= policy.maxCrashCount {
|
|
403
|
+
return try recover(
|
|
404
|
+
failedHash: current.hash,
|
|
405
|
+
crashCount: unacknowledgedLaunchCount,
|
|
406
|
+
quarantine: true,
|
|
407
|
+
emitEvent: true,
|
|
408
|
+
ledger: &ledger
|
|
409
|
+
)
|
|
410
|
+
}
|
|
411
|
+
|
|
412
|
+
let attemptId = ledger.reservedAttemptId ?? makeId()
|
|
413
|
+
ledger.phase = .launching
|
|
414
|
+
ledger.reservedAttemptId = nil
|
|
415
|
+
ledger.activeAttempt = BundleDropStartupRecoveryAttempt(
|
|
416
|
+
hash: current.hash,
|
|
417
|
+
attemptId: attemptId,
|
|
418
|
+
processToken: processToken,
|
|
419
|
+
startedAt: now(),
|
|
420
|
+
unacknowledgedLaunchCount: unacknowledgedLaunchCount,
|
|
421
|
+
contentAppeared: false
|
|
422
|
+
)
|
|
423
|
+
try commit(&ledger)
|
|
424
|
+
try failpoint?("afterLaunchPersisted")
|
|
425
|
+
return BundleDropStartupSelection(
|
|
426
|
+
bundleURL: current.bundleURL,
|
|
427
|
+
attemptHash: current.hash,
|
|
428
|
+
attemptId: attemptId
|
|
429
|
+
)
|
|
430
|
+
} catch BundleDropStartupRecoveryError.ledgerCorrupt {
|
|
431
|
+
return repairCorruptLedger()
|
|
432
|
+
} catch {
|
|
433
|
+
// Failing closed here prevents an untracked candidate from booting.
|
|
434
|
+
return BundleDropStartupSelection(bundleURL: nil, attemptHash: nil, attemptId: nil)
|
|
435
|
+
}
|
|
436
|
+
}
|
|
437
|
+
}
|
|
438
|
+
|
|
439
|
+
func markContentAppeared(hash: String, attemptId: String) -> Double? {
|
|
440
|
+
withLock {
|
|
441
|
+
do {
|
|
442
|
+
var ledger = try readLedgerImportingLegacyState()
|
|
443
|
+
guard ledger.phase == .launching,
|
|
444
|
+
ledger.candidateHash == hash,
|
|
445
|
+
ledger.activeAttempt?.hash == hash,
|
|
446
|
+
ledger.activeAttempt?.attemptId == attemptId,
|
|
447
|
+
ledger.activeAttempt?.contentAppeared == false,
|
|
448
|
+
ledger.policy?.healthCheckMode == "auto" else {
|
|
449
|
+
return nil
|
|
450
|
+
}
|
|
451
|
+
ledger.activeAttempt?.contentAppeared = true
|
|
452
|
+
try commit(&ledger)
|
|
453
|
+
return ledger.policy?.healthyAfterSec ?? 0
|
|
454
|
+
} catch {
|
|
455
|
+
return nil
|
|
456
|
+
}
|
|
457
|
+
}
|
|
458
|
+
}
|
|
459
|
+
|
|
460
|
+
func markHealthy(hash: String, attemptId: String) -> Bool {
|
|
461
|
+
withLock {
|
|
462
|
+
do {
|
|
463
|
+
var ledger = try readLedgerImportingLegacyState()
|
|
464
|
+
guard isCurrentBundleEligible(hash: hash, ledger: ledger) else {
|
|
465
|
+
return false
|
|
466
|
+
}
|
|
467
|
+
if ledger.phase == .stable,
|
|
468
|
+
ledger.stableHash == hash,
|
|
469
|
+
ledger.lastHealthyAttemptId == attemptId {
|
|
470
|
+
return true
|
|
471
|
+
}
|
|
472
|
+
guard ledger.phase == .launching,
|
|
473
|
+
ledger.candidateHash == hash,
|
|
474
|
+
ledger.activeAttempt?.hash == hash,
|
|
475
|
+
ledger.activeAttempt?.attemptId == attemptId else {
|
|
476
|
+
return false
|
|
477
|
+
}
|
|
478
|
+
ledger.phase = .stable
|
|
479
|
+
ledger.previousStableHash = ledger.stableHash
|
|
480
|
+
ledger.stableHash = hash
|
|
481
|
+
ledger.lastHealthyAttemptId = attemptId
|
|
482
|
+
ledger.candidateHash = nil
|
|
483
|
+
ledger.activeAttempt = nil
|
|
484
|
+
ledger.reservedAttemptId = nil
|
|
485
|
+
ledger.policy = nil
|
|
486
|
+
try commit(&ledger)
|
|
487
|
+
try failpoint?("afterHealthCommitted")
|
|
488
|
+
return true
|
|
489
|
+
} catch {
|
|
490
|
+
return false
|
|
491
|
+
}
|
|
492
|
+
}
|
|
493
|
+
}
|
|
494
|
+
|
|
495
|
+
func passiveCurrentBundle() -> URL? {
|
|
496
|
+
withLock {
|
|
497
|
+
guard hasExpectedIdentity else { return nil }
|
|
498
|
+
do {
|
|
499
|
+
guard let current = BundleDropOtaResolver.readPointer(
|
|
500
|
+
named: "current.json",
|
|
501
|
+
bundleDropRoot: bundleDropRoot,
|
|
502
|
+
expectedRuntimeVersion: expectedRuntimeVersion,
|
|
503
|
+
fileManager: fileManager
|
|
504
|
+
), let ledger = try readLedgerFromDisk() else {
|
|
505
|
+
return nil
|
|
506
|
+
}
|
|
507
|
+
guard ledger.binaryIdentity == expectedBinaryIdentity,
|
|
508
|
+
ledger.runtimeIdentity == expectedRuntimeVersion,
|
|
509
|
+
!ledger.revokedHashes.contains(current.hash),
|
|
510
|
+
!ledger.quarantinedHashes.contains(current.hash) else {
|
|
511
|
+
return nil
|
|
512
|
+
}
|
|
513
|
+
let isStable = ledger.stableHash == current.hash &&
|
|
514
|
+
(ledger.phase == .stable || ledger.phase == .recovered)
|
|
515
|
+
let isCandidate = ledger.candidateHash == current.hash &&
|
|
516
|
+
(ledger.phase == .armed || ledger.phase == .launching) &&
|
|
517
|
+
ledger.policy != nil
|
|
518
|
+
return isStable || isCandidate ? current.bundleURL : nil
|
|
519
|
+
} catch {
|
|
520
|
+
return nil
|
|
521
|
+
}
|
|
522
|
+
}
|
|
523
|
+
}
|
|
524
|
+
|
|
525
|
+
func setRevokedHashes(_ hashes: [String]) throws {
|
|
526
|
+
try withLock {
|
|
527
|
+
guard hashes.allSatisfy(Self.isCanonicalHash) else {
|
|
528
|
+
throw BundleDropStartupRecoveryError.invalidHash
|
|
529
|
+
}
|
|
530
|
+
var ledger = try readLedgerImportingLegacyState()
|
|
531
|
+
let normalized = Array(Set(hashes)).sorted()
|
|
532
|
+
guard normalized != ledger.revokedHashes else { return }
|
|
533
|
+
ledger.revokedHashes = normalized
|
|
534
|
+
try commit(&ledger)
|
|
535
|
+
}
|
|
536
|
+
}
|
|
537
|
+
|
|
538
|
+
func acknowledgeRecovery(eventId: String) throws -> Bool {
|
|
539
|
+
try withLock {
|
|
540
|
+
var ledger = try readLedgerImportingLegacyState()
|
|
541
|
+
let originalCount = ledger.pendingRecoveryEvents.count
|
|
542
|
+
ledger.pendingRecoveryEvents.removeAll { $0.id == eventId }
|
|
543
|
+
guard ledger.pendingRecoveryEvents.count != originalCount else { return false }
|
|
544
|
+
try commit(&ledger)
|
|
545
|
+
return true
|
|
546
|
+
}
|
|
547
|
+
}
|
|
548
|
+
|
|
549
|
+
func rollback(forceEmbedded: Bool) throws -> BundleDropStartupRollbackResult {
|
|
550
|
+
try withLock {
|
|
551
|
+
var ledger = try readLedgerImportingLegacyState()
|
|
552
|
+
let current = BundleDropOtaResolver.readPointer(
|
|
553
|
+
named: "current.json",
|
|
554
|
+
bundleDropRoot: bundleDropRoot,
|
|
555
|
+
expectedRuntimeVersion: expectedRuntimeVersion,
|
|
556
|
+
fileManager: fileManager
|
|
557
|
+
)
|
|
558
|
+
let fallbackHash = forceEmbedded ? nil : provenFallbackHash(
|
|
559
|
+
failedHash: current?.hash,
|
|
560
|
+
ledger: ledger
|
|
561
|
+
)
|
|
562
|
+
let fallback = fallbackHash.flatMap { hash in
|
|
563
|
+
verifiedPreviousPointer(hash: hash, ledger: ledger)
|
|
564
|
+
}
|
|
565
|
+
|
|
566
|
+
ledger.phase = fallback == nil ? .idle : .stable
|
|
567
|
+
ledger.candidateHash = nil
|
|
568
|
+
ledger.previousStableHash = nil
|
|
569
|
+
ledger.stableHash = fallback?.hash
|
|
570
|
+
ledger.lastHealthyAttemptId = nil
|
|
571
|
+
ledger.activeAttempt = nil
|
|
572
|
+
ledger.reservedAttemptId = nil
|
|
573
|
+
ledger.policy = nil
|
|
574
|
+
ledger.pendingTransition = BundleDropStartupRecoveryTransition(
|
|
575
|
+
kind: "rollback",
|
|
576
|
+
targetHash: fallback?.hash
|
|
577
|
+
)
|
|
578
|
+
try commit(&ledger)
|
|
579
|
+
try failpoint?("afterRollbackPrepared")
|
|
580
|
+
try completePendingTransition(ledger: &ledger)
|
|
581
|
+
return BundleDropStartupRollbackResult(
|
|
582
|
+
rolledBack: current != nil,
|
|
583
|
+
toEmbedded: fallback == nil,
|
|
584
|
+
hash: fallback?.hash
|
|
585
|
+
)
|
|
586
|
+
}
|
|
587
|
+
}
|
|
588
|
+
|
|
589
|
+
func snapshot() throws -> [String: Any] {
|
|
590
|
+
try withLock {
|
|
591
|
+
let ledger = try readLedgerImportingLegacyState()
|
|
592
|
+
var result: [String: Any] = [
|
|
593
|
+
"protocolVersion": Self.protocolVersion,
|
|
594
|
+
"revision": ledger.revision,
|
|
595
|
+
"phase": ledger.phase.rawValue,
|
|
596
|
+
"quarantinedHashes": ledger.quarantinedHashes.sorted(),
|
|
597
|
+
"pendingRecoveryEvents": ledger.pendingRecoveryEvents.map(Self.eventDictionary),
|
|
598
|
+
]
|
|
599
|
+
if let candidateHash = ledger.candidateHash {
|
|
600
|
+
result["candidateHash"] = candidateHash
|
|
601
|
+
}
|
|
602
|
+
if let stableHash = ledger.stableHash {
|
|
603
|
+
result["stableHash"] = stableHash
|
|
604
|
+
}
|
|
605
|
+
if let policy = ledger.policy {
|
|
606
|
+
result["policy"] = [
|
|
607
|
+
"maxCrashCount": policy.maxCrashCount,
|
|
608
|
+
"healthCheckMode": policy.healthCheckMode,
|
|
609
|
+
"healthyAfterSec": policy.healthyAfterSec,
|
|
610
|
+
]
|
|
611
|
+
}
|
|
612
|
+
if let attempt = ledger.activeAttempt, ledger.phase == .launching {
|
|
613
|
+
result["activeAttempt"] = [
|
|
614
|
+
"hash": attempt.hash,
|
|
615
|
+
"attemptId": attempt.attemptId,
|
|
616
|
+
"status": "launching",
|
|
617
|
+
"unacknowledgedLaunchCount": attempt.unacknowledgedLaunchCount,
|
|
618
|
+
]
|
|
619
|
+
} else {
|
|
620
|
+
result["activeAttempt"] = NSNull()
|
|
621
|
+
}
|
|
622
|
+
return result
|
|
623
|
+
}
|
|
624
|
+
}
|
|
625
|
+
|
|
626
|
+
private func recover(
|
|
627
|
+
failedHash: String,
|
|
628
|
+
crashCount: Int,
|
|
629
|
+
quarantine: Bool,
|
|
630
|
+
emitEvent: Bool,
|
|
631
|
+
ledger: inout BundleDropStartupRecoveryLedger
|
|
632
|
+
) throws -> BundleDropStartupSelection {
|
|
633
|
+
let fallbackHash = provenFallbackHash(failedHash: failedHash, ledger: ledger)
|
|
634
|
+
let fallback = fallbackHash.flatMap { hash in
|
|
635
|
+
verifiedPreviousPointer(hash: hash, ledger: ledger)
|
|
636
|
+
}
|
|
637
|
+
|
|
638
|
+
if quarantine {
|
|
639
|
+
ledger.quarantinedHashes = Array(Set(ledger.quarantinedHashes + [failedHash])).sorted()
|
|
640
|
+
}
|
|
641
|
+
if emitEvent {
|
|
642
|
+
ledger.pendingRecoveryEvents.append(BundleDropStartupRecoveryEvent(
|
|
643
|
+
id: makeId(),
|
|
644
|
+
failedHash: failedHash,
|
|
645
|
+
recoveryTarget: fallback == nil ? "embedded" : "previous",
|
|
646
|
+
recoveredHash: fallback?.hash,
|
|
647
|
+
crashCount: crashCount,
|
|
648
|
+
reason: "crash_loop",
|
|
649
|
+
failedAt: now()
|
|
650
|
+
))
|
|
651
|
+
if ledger.pendingRecoveryEvents.count > 20 {
|
|
652
|
+
ledger.pendingRecoveryEvents.removeFirst(ledger.pendingRecoveryEvents.count - 20)
|
|
653
|
+
}
|
|
654
|
+
}
|
|
655
|
+
|
|
656
|
+
ledger.phase = .recovered
|
|
657
|
+
ledger.candidateHash = failedHash
|
|
658
|
+
ledger.previousStableHash = nil
|
|
659
|
+
ledger.stableHash = fallback?.hash
|
|
660
|
+
ledger.lastHealthyAttemptId = nil
|
|
661
|
+
ledger.activeAttempt = nil
|
|
662
|
+
ledger.reservedAttemptId = nil
|
|
663
|
+
ledger.policy = nil
|
|
664
|
+
ledger.pendingTransition = BundleDropStartupRecoveryTransition(
|
|
665
|
+
kind: "recovery",
|
|
666
|
+
targetHash: fallback?.hash
|
|
667
|
+
)
|
|
668
|
+
try commit(&ledger)
|
|
669
|
+
try failpoint?("afterRecoveryPrepared")
|
|
670
|
+
try completePendingTransition(ledger: &ledger)
|
|
671
|
+
return BundleDropStartupSelection(
|
|
672
|
+
bundleURL: fallback?.bundleURL,
|
|
673
|
+
attemptHash: nil,
|
|
674
|
+
attemptId: nil
|
|
675
|
+
)
|
|
676
|
+
}
|
|
677
|
+
|
|
678
|
+
private func completePendingTransition(
|
|
679
|
+
ledger: inout BundleDropStartupRecoveryLedger
|
|
680
|
+
) throws {
|
|
681
|
+
guard var transition = ledger.pendingTransition else { return }
|
|
682
|
+
if let targetHash = transition.targetHash,
|
|
683
|
+
!isPendingTransitionTargetEligible(targetHash, ledger: ledger) {
|
|
684
|
+
transition = BundleDropStartupRecoveryTransition(
|
|
685
|
+
kind: transition.kind,
|
|
686
|
+
targetHash: nil
|
|
687
|
+
)
|
|
688
|
+
ledger.stableHash = nil
|
|
689
|
+
ledger.previousStableHash = nil
|
|
690
|
+
ledger.pendingTransition = transition
|
|
691
|
+
if transition.kind == "recovery",
|
|
692
|
+
let eventIndex = ledger.pendingRecoveryEvents.lastIndex(where: {
|
|
693
|
+
$0.recoveryTarget == "previous" && $0.recoveredHash == targetHash
|
|
694
|
+
}) {
|
|
695
|
+
let event = ledger.pendingRecoveryEvents[eventIndex]
|
|
696
|
+
ledger.pendingRecoveryEvents[eventIndex] = BundleDropStartupRecoveryEvent(
|
|
697
|
+
id: event.id,
|
|
698
|
+
failedHash: event.failedHash,
|
|
699
|
+
recoveryTarget: "embedded",
|
|
700
|
+
recoveredHash: nil,
|
|
701
|
+
crashCount: event.crashCount,
|
|
702
|
+
reason: event.reason,
|
|
703
|
+
failedAt: event.failedAt
|
|
704
|
+
)
|
|
705
|
+
}
|
|
706
|
+
// Persist the downgrade before touching pointers so another interruption
|
|
707
|
+
// can only resume toward embedded, never toward the unavailable target.
|
|
708
|
+
try commit(&ledger)
|
|
709
|
+
}
|
|
710
|
+
try applyPendingPointerTransition(transition)
|
|
711
|
+
ledger.pendingTransition = nil
|
|
712
|
+
try commit(&ledger)
|
|
713
|
+
}
|
|
714
|
+
|
|
715
|
+
private func applyPendingPointerTransition(
|
|
716
|
+
_ transition: BundleDropStartupRecoveryTransition
|
|
717
|
+
) throws {
|
|
718
|
+
guard transition.kind == "recovery" || transition.kind == "rollback" else {
|
|
719
|
+
throw BundleDropStartupRecoveryError.ledgerCorrupt
|
|
720
|
+
}
|
|
721
|
+
let failpointPrefix = transition.kind == "recovery" ? "recoveryCurrent" : "rollbackCurrent"
|
|
722
|
+
if let targetHash = transition.targetHash {
|
|
723
|
+
guard BundleDropOtaResolver.readBundle(
|
|
724
|
+
hash: targetHash,
|
|
725
|
+
bundleDropRoot: bundleDropRoot,
|
|
726
|
+
expectedRuntimeVersion: expectedRuntimeVersion,
|
|
727
|
+
fileManager: fileManager
|
|
728
|
+
) != nil else {
|
|
729
|
+
throw BundleDropStartupRecoveryError.candidateUnavailable
|
|
730
|
+
}
|
|
731
|
+
try writePointer(named: "current.json", hash: targetHash, failpointPrefix: failpointPrefix)
|
|
732
|
+
} else {
|
|
733
|
+
try deleteCurrentPointer(failpointPrefix: failpointPrefix)
|
|
734
|
+
}
|
|
735
|
+
try? BundleDropOtaResolver.deletePointer(
|
|
736
|
+
named: "previous.json",
|
|
737
|
+
bundleDropRoot: bundleDropRoot,
|
|
738
|
+
fileManager: fileManager
|
|
739
|
+
)
|
|
740
|
+
}
|
|
741
|
+
|
|
742
|
+
private func isPendingTransitionTargetEligible(
|
|
743
|
+
_ hash: String,
|
|
744
|
+
ledger: BundleDropStartupRecoveryLedger
|
|
745
|
+
) -> Bool {
|
|
746
|
+
guard hasExpectedIdentity,
|
|
747
|
+
ledger.binaryIdentity == expectedBinaryIdentity,
|
|
748
|
+
ledger.runtimeIdentity == expectedRuntimeVersion,
|
|
749
|
+
!ledger.quarantinedHashes.contains(hash),
|
|
750
|
+
!ledger.revokedHashes.contains(hash) else {
|
|
751
|
+
return false
|
|
752
|
+
}
|
|
753
|
+
return BundleDropOtaResolver.readBundle(
|
|
754
|
+
hash: hash,
|
|
755
|
+
bundleDropRoot: bundleDropRoot,
|
|
756
|
+
expectedRuntimeVersion: expectedRuntimeVersion,
|
|
757
|
+
fileManager: fileManager
|
|
758
|
+
) != nil
|
|
759
|
+
}
|
|
760
|
+
|
|
761
|
+
private func provenFallbackHash(
|
|
762
|
+
failedHash: String?,
|
|
763
|
+
ledger: BundleDropStartupRecoveryLedger
|
|
764
|
+
) -> String? {
|
|
765
|
+
guard let failedHash else { return nil }
|
|
766
|
+
if ledger.candidateHash == failedHash {
|
|
767
|
+
return ledger.stableHash
|
|
768
|
+
}
|
|
769
|
+
if ledger.stableHash == failedHash {
|
|
770
|
+
return ledger.previousStableHash
|
|
771
|
+
}
|
|
772
|
+
return nil
|
|
773
|
+
}
|
|
774
|
+
|
|
775
|
+
private func verifiedPreviousPointer(
|
|
776
|
+
hash: String,
|
|
777
|
+
ledger: BundleDropStartupRecoveryLedger
|
|
778
|
+
) -> BundleDropOtaPointer? {
|
|
779
|
+
guard hasExpectedIdentity,
|
|
780
|
+
!ledger.quarantinedHashes.contains(hash),
|
|
781
|
+
!ledger.revokedHashes.contains(hash) else {
|
|
782
|
+
return nil
|
|
783
|
+
}
|
|
784
|
+
let previous = BundleDropOtaResolver.readPointer(
|
|
785
|
+
named: "previous.json",
|
|
786
|
+
bundleDropRoot: bundleDropRoot,
|
|
787
|
+
expectedRuntimeVersion: expectedRuntimeVersion,
|
|
788
|
+
fileManager: fileManager
|
|
789
|
+
)
|
|
790
|
+
return previous?.hash == hash ? previous : nil
|
|
791
|
+
}
|
|
792
|
+
|
|
793
|
+
private func isCurrentBundleEligible(
|
|
794
|
+
hash: String,
|
|
795
|
+
ledger: BundleDropStartupRecoveryLedger
|
|
796
|
+
) -> Bool {
|
|
797
|
+
guard hasExpectedIdentity,
|
|
798
|
+
ledger.binaryIdentity == expectedBinaryIdentity,
|
|
799
|
+
ledger.runtimeIdentity == expectedRuntimeVersion,
|
|
800
|
+
!ledger.quarantinedHashes.contains(hash),
|
|
801
|
+
!ledger.revokedHashes.contains(hash),
|
|
802
|
+
let current = BundleDropOtaResolver.readPointer(
|
|
803
|
+
named: "current.json",
|
|
804
|
+
bundleDropRoot: bundleDropRoot,
|
|
805
|
+
expectedRuntimeVersion: expectedRuntimeVersion,
|
|
806
|
+
fileManager: fileManager
|
|
807
|
+
),
|
|
808
|
+
current.hash == hash else {
|
|
809
|
+
return false
|
|
810
|
+
}
|
|
811
|
+
return BundleDropOtaResolver.readBundle(
|
|
812
|
+
hash: hash,
|
|
813
|
+
bundleDropRoot: bundleDropRoot,
|
|
814
|
+
expectedRuntimeVersion: expectedRuntimeVersion,
|
|
815
|
+
fileManager: fileManager
|
|
816
|
+
) != nil
|
|
817
|
+
}
|
|
818
|
+
|
|
819
|
+
private func readLedgerImportingLegacyState() throws -> BundleDropStartupRecoveryLedger {
|
|
820
|
+
var ledger = try readLedgerFromDisk() ?? BundleDropStartupRecoveryLedger()
|
|
821
|
+
try bindLedgerToExpectedIdentity(&ledger)
|
|
822
|
+
guard ledger.legacyFailuresImported != true else {
|
|
823
|
+
return ledger
|
|
824
|
+
}
|
|
825
|
+
|
|
826
|
+
if fileManager.fileExists(atPath: legacyStateURL.path),
|
|
827
|
+
let data = try? Data(contentsOf: legacyStateURL),
|
|
828
|
+
let legacy = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
|
|
829
|
+
let failedBundles = legacy["failedBundles"] as? [String: Any] {
|
|
830
|
+
let imported = Self.newestLegacyFailureHashes(failedBundles)
|
|
831
|
+
let merged = Array(Set(ledger.quarantinedHashes + imported)).sorted()
|
|
832
|
+
ledger.quarantinedHashes = merged
|
|
833
|
+
}
|
|
834
|
+
ledger.legacyFailuresImported = true
|
|
835
|
+
try commit(&ledger)
|
|
836
|
+
return ledger
|
|
837
|
+
}
|
|
838
|
+
|
|
839
|
+
private var hasExpectedIdentity: Bool {
|
|
840
|
+
expectedRuntimeVersion?.isEmpty == false && expectedBinaryIdentity?.isEmpty == false
|
|
841
|
+
}
|
|
842
|
+
|
|
843
|
+
private func bindLedgerToExpectedIdentity(
|
|
844
|
+
_ ledger: inout BundleDropStartupRecoveryLedger
|
|
845
|
+
) throws {
|
|
846
|
+
guard let runtimeIdentity = expectedRuntimeVersion,
|
|
847
|
+
!runtimeIdentity.isEmpty,
|
|
848
|
+
let binaryIdentity = expectedBinaryIdentity,
|
|
849
|
+
!binaryIdentity.isEmpty else {
|
|
850
|
+
throw BundleDropStartupRecoveryError.candidateUnavailable
|
|
851
|
+
}
|
|
852
|
+
guard ledger.runtimeIdentity != runtimeIdentity || ledger.binaryIdentity != binaryIdentity else {
|
|
853
|
+
return
|
|
854
|
+
}
|
|
855
|
+
|
|
856
|
+
let previousRevision = ledger.revision
|
|
857
|
+
ledger = BundleDropStartupRecoveryLedger()
|
|
858
|
+
ledger.revision = previousRevision
|
|
859
|
+
ledger.runtimeIdentity = runtimeIdentity
|
|
860
|
+
ledger.binaryIdentity = binaryIdentity
|
|
861
|
+
try BundleDropOtaResolver.deletePointer(
|
|
862
|
+
named: "current.json",
|
|
863
|
+
bundleDropRoot: bundleDropRoot,
|
|
864
|
+
fileManager: fileManager
|
|
865
|
+
)
|
|
866
|
+
try BundleDropOtaResolver.deletePointer(
|
|
867
|
+
named: "previous.json",
|
|
868
|
+
bundleDropRoot: bundleDropRoot,
|
|
869
|
+
fileManager: fileManager
|
|
870
|
+
)
|
|
871
|
+
try commit(&ledger)
|
|
872
|
+
}
|
|
873
|
+
|
|
874
|
+
private func readLedgerFromDisk() throws -> BundleDropStartupRecoveryLedger? {
|
|
875
|
+
guard fileManager.fileExists(atPath: ledgerURL.path) else { return nil }
|
|
876
|
+
do {
|
|
877
|
+
let ledger = try JSONDecoder().decode(
|
|
878
|
+
BundleDropStartupRecoveryLedger.self,
|
|
879
|
+
from: Data(contentsOf: ledgerURL)
|
|
880
|
+
)
|
|
881
|
+
guard Self.isValid(ledger) else {
|
|
882
|
+
throw BundleDropStartupRecoveryError.ledgerCorrupt
|
|
883
|
+
}
|
|
884
|
+
return ledger
|
|
885
|
+
} catch let error as BundleDropStartupRecoveryError {
|
|
886
|
+
throw error
|
|
887
|
+
} catch {
|
|
888
|
+
throw BundleDropStartupRecoveryError.ledgerCorrupt
|
|
889
|
+
}
|
|
890
|
+
}
|
|
891
|
+
|
|
892
|
+
private func repairCorruptLedger() -> BundleDropStartupSelection {
|
|
893
|
+
guard let runtimeIdentity = expectedRuntimeVersion,
|
|
894
|
+
!runtimeIdentity.isEmpty,
|
|
895
|
+
let binaryIdentity = expectedBinaryIdentity,
|
|
896
|
+
!binaryIdentity.isEmpty else {
|
|
897
|
+
return BundleDropStartupSelection(bundleURL: nil, attemptHash: nil, attemptId: nil)
|
|
898
|
+
}
|
|
899
|
+
|
|
900
|
+
let currentHash = BundleDropOtaResolver.readPointer(
|
|
901
|
+
named: "current.json",
|
|
902
|
+
bundleDropRoot: bundleDropRoot,
|
|
903
|
+
expectedRuntimeVersion: expectedRuntimeVersion,
|
|
904
|
+
fileManager: fileManager
|
|
905
|
+
)?.hash
|
|
906
|
+
var replacement = BundleDropStartupRecoveryLedger()
|
|
907
|
+
replacement.revision = 1
|
|
908
|
+
replacement.binaryIdentity = binaryIdentity
|
|
909
|
+
replacement.runtimeIdentity = runtimeIdentity
|
|
910
|
+
replacement.legacyFailuresImported = true
|
|
911
|
+
replacement.phase = .recovered
|
|
912
|
+
replacement.quarantinedHashes = currentHash.map { [$0] } ?? []
|
|
913
|
+
|
|
914
|
+
do {
|
|
915
|
+
Self.ledgerCommitLock.lock()
|
|
916
|
+
defer { Self.ledgerCommitLock.unlock() }
|
|
917
|
+
try writeLedgerAtomically(replacement)
|
|
918
|
+
try BundleDropOtaResolver.deletePointer(
|
|
919
|
+
named: "current.json",
|
|
920
|
+
bundleDropRoot: bundleDropRoot,
|
|
921
|
+
fileManager: fileManager
|
|
922
|
+
)
|
|
923
|
+
try BundleDropOtaResolver.deletePointer(
|
|
924
|
+
named: "previous.json",
|
|
925
|
+
bundleDropRoot: bundleDropRoot,
|
|
926
|
+
fileManager: fileManager
|
|
927
|
+
)
|
|
928
|
+
} catch {
|
|
929
|
+
// The caller still fails closed to embedded. A later launch can retry the
|
|
930
|
+
// repair without trusting any health claim from the corrupt ledger.
|
|
931
|
+
}
|
|
932
|
+
return BundleDropStartupSelection(bundleURL: nil, attemptHash: nil, attemptId: nil)
|
|
933
|
+
}
|
|
934
|
+
|
|
935
|
+
private func commit(_ ledger: inout BundleDropStartupRecoveryLedger) throws {
|
|
936
|
+
ledger.schemaVersion = Self.protocolVersion
|
|
937
|
+
try fileManager.createDirectory(at: bundleDropRoot, withIntermediateDirectories: true)
|
|
938
|
+
try failpoint?("beforeLedgerWrite")
|
|
939
|
+
Self.ledgerCommitLock.lock()
|
|
940
|
+
do {
|
|
941
|
+
let persistedRevision = try readLedgerFromDisk()?.revision ?? 0
|
|
942
|
+
guard persistedRevision == ledger.revision else {
|
|
943
|
+
throw BundleDropStartupRecoveryError.staleLedger
|
|
944
|
+
}
|
|
945
|
+
ledger.revision += 1
|
|
946
|
+
} catch {
|
|
947
|
+
Self.ledgerCommitLock.unlock()
|
|
948
|
+
throw error
|
|
949
|
+
}
|
|
950
|
+
do {
|
|
951
|
+
try writeLedgerAtomically(ledger)
|
|
952
|
+
} catch {
|
|
953
|
+
Self.ledgerCommitLock.unlock()
|
|
954
|
+
throw error
|
|
955
|
+
}
|
|
956
|
+
Self.ledgerCommitLock.unlock()
|
|
957
|
+
try failpoint?("afterLedgerWrite")
|
|
958
|
+
}
|
|
959
|
+
|
|
960
|
+
private func writeLedgerAtomically(_ ledger: BundleDropStartupRecoveryLedger) throws {
|
|
961
|
+
let encoder = JSONEncoder()
|
|
962
|
+
encoder.outputFormatting = [.sortedKeys]
|
|
963
|
+
let temporaryURL = bundleDropRoot.appendingPathComponent(
|
|
964
|
+
".recovery-ledger-\(UUID().uuidString).tmp"
|
|
965
|
+
)
|
|
966
|
+
do {
|
|
967
|
+
try encoder.encode(ledger).write(to: temporaryURL)
|
|
968
|
+
let handle = try FileHandle(forWritingTo: temporaryURL)
|
|
969
|
+
try handle.synchronize()
|
|
970
|
+
try handle.close()
|
|
971
|
+
if fileManager.fileExists(atPath: ledgerURL.path) {
|
|
972
|
+
_ = try fileManager.replaceItemAt(ledgerURL, withItemAt: temporaryURL)
|
|
973
|
+
} else {
|
|
974
|
+
try fileManager.moveItem(at: temporaryURL, to: ledgerURL)
|
|
975
|
+
}
|
|
976
|
+
} catch {
|
|
977
|
+
try? fileManager.removeItem(at: temporaryURL)
|
|
978
|
+
throw error
|
|
979
|
+
}
|
|
980
|
+
}
|
|
981
|
+
|
|
982
|
+
private func writePointer(named filename: String, hash: String, failpointPrefix: String) throws {
|
|
983
|
+
try failpoint?("before\(failpointPrefix.prefix(1).uppercased())\(failpointPrefix.dropFirst())Write")
|
|
984
|
+
try BundleDropOtaResolver.writePointer(
|
|
985
|
+
named: filename,
|
|
986
|
+
hash: hash,
|
|
987
|
+
bundleDropRoot: bundleDropRoot,
|
|
988
|
+
fileManager: fileManager
|
|
989
|
+
)
|
|
990
|
+
try failpoint?("after\(failpointPrefix.prefix(1).uppercased())\(failpointPrefix.dropFirst())Write")
|
|
991
|
+
}
|
|
992
|
+
|
|
993
|
+
private func deleteCurrentPointer(failpointPrefix: String) throws {
|
|
994
|
+
try failpoint?("before\(failpointPrefix.prefix(1).uppercased())\(failpointPrefix.dropFirst())Delete")
|
|
995
|
+
try BundleDropOtaResolver.deletePointer(
|
|
996
|
+
named: "current.json",
|
|
997
|
+
bundleDropRoot: bundleDropRoot,
|
|
998
|
+
fileManager: fileManager
|
|
999
|
+
)
|
|
1000
|
+
try failpoint?("after\(failpointPrefix.prefix(1).uppercased())\(failpointPrefix.dropFirst())Delete")
|
|
1001
|
+
}
|
|
1002
|
+
|
|
1003
|
+
private func withLock<T>(_ operation: () throws -> T) rethrows -> T {
|
|
1004
|
+
lock.lock()
|
|
1005
|
+
defer { lock.unlock() }
|
|
1006
|
+
return try operation()
|
|
1007
|
+
}
|
|
1008
|
+
|
|
1009
|
+
private static func isCanonicalHash(_ value: String) -> Bool {
|
|
1010
|
+
value.range(of: "^[a-f0-9]{64}$", options: .regularExpression) != nil
|
|
1011
|
+
}
|
|
1012
|
+
|
|
1013
|
+
private static func newestLegacyFailureHashes(
|
|
1014
|
+
_ failedBundles: [String: Any]
|
|
1015
|
+
) -> [String] {
|
|
1016
|
+
failedBundles.compactMap { hash, value -> (hash: String, failedAt: Double?)? in
|
|
1017
|
+
guard isCanonicalHash(hash) else { return nil }
|
|
1018
|
+
let record = value as? [String: Any]
|
|
1019
|
+
let rawFailedAt = record?["failedAt"]
|
|
1020
|
+
let number = rawFailedAt is Bool ? nil : rawFailedAt as? NSNumber
|
|
1021
|
+
let failedAt = number?.doubleValue
|
|
1022
|
+
return (
|
|
1023
|
+
hash,
|
|
1024
|
+
failedAt.flatMap { $0.isFinite && $0 >= 0 ? $0 : nil }
|
|
1025
|
+
)
|
|
1026
|
+
}
|
|
1027
|
+
.sorted { left, right in
|
|
1028
|
+
switch (left.failedAt, right.failedAt) {
|
|
1029
|
+
case let (leftDate?, rightDate?) where leftDate != rightDate:
|
|
1030
|
+
return leftDate > rightDate
|
|
1031
|
+
case (_?, nil):
|
|
1032
|
+
return true
|
|
1033
|
+
case (nil, _?):
|
|
1034
|
+
return false
|
|
1035
|
+
default:
|
|
1036
|
+
return left.hash < right.hash
|
|
1037
|
+
}
|
|
1038
|
+
}
|
|
1039
|
+
.prefix(20)
|
|
1040
|
+
.map(\.hash)
|
|
1041
|
+
}
|
|
1042
|
+
|
|
1043
|
+
private static func isValid(_ ledger: BundleDropStartupRecoveryLedger) -> Bool {
|
|
1044
|
+
guard ledger.schemaVersion == protocolVersion,
|
|
1045
|
+
ledger.revision >= 0,
|
|
1046
|
+
ledger.binaryIdentity.map({ !$0.isEmpty }) ?? true,
|
|
1047
|
+
ledger.runtimeIdentity.map({ !$0.isEmpty }) ?? true,
|
|
1048
|
+
[ledger.candidateHash, ledger.stableHash, ledger.previousStableHash]
|
|
1049
|
+
.compactMap({ $0 })
|
|
1050
|
+
.allSatisfy(isCanonicalHash),
|
|
1051
|
+
ledger.quarantinedHashes.allSatisfy(isCanonicalHash),
|
|
1052
|
+
ledger.revokedHashes.allSatisfy(isCanonicalHash),
|
|
1053
|
+
Set(ledger.quarantinedHashes).count == ledger.quarantinedHashes.count,
|
|
1054
|
+
Set(ledger.revokedHashes).count == ledger.revokedHashes.count else {
|
|
1055
|
+
return false
|
|
1056
|
+
}
|
|
1057
|
+
if let policy = ledger.policy,
|
|
1058
|
+
policy.maxCrashCount < 0 ||
|
|
1059
|
+
!policy.healthyAfterSec.isFinite ||
|
|
1060
|
+
policy.healthyAfterSec < 0 ||
|
|
1061
|
+
(policy.healthCheckMode != "auto" && policy.healthCheckMode != "manual") {
|
|
1062
|
+
return false
|
|
1063
|
+
}
|
|
1064
|
+
if let attempt = ledger.activeAttempt,
|
|
1065
|
+
!isCanonicalHash(attempt.hash) ||
|
|
1066
|
+
attempt.attemptId.isEmpty ||
|
|
1067
|
+
attempt.processToken.isEmpty ||
|
|
1068
|
+
attempt.unacknowledgedLaunchCount < 0 {
|
|
1069
|
+
return false
|
|
1070
|
+
}
|
|
1071
|
+
if let reservedAttemptId = ledger.reservedAttemptId, reservedAttemptId.isEmpty {
|
|
1072
|
+
return false
|
|
1073
|
+
}
|
|
1074
|
+
if let lastHealthyAttemptId = ledger.lastHealthyAttemptId, lastHealthyAttemptId.isEmpty {
|
|
1075
|
+
return false
|
|
1076
|
+
}
|
|
1077
|
+
if let transition = ledger.pendingTransition,
|
|
1078
|
+
(transition.kind != "recovery" && transition.kind != "rollback") ||
|
|
1079
|
+
(transition.targetHash != nil && !isCanonicalHash(transition.targetHash!)) {
|
|
1080
|
+
return false
|
|
1081
|
+
}
|
|
1082
|
+
return ledger.pendingRecoveryEvents.allSatisfy { event in
|
|
1083
|
+
!event.id.isEmpty &&
|
|
1084
|
+
isCanonicalHash(event.failedHash) &&
|
|
1085
|
+
event.crashCount >= 0 &&
|
|
1086
|
+
event.failedAt >= 0 &&
|
|
1087
|
+
event.reason == "crash_loop" &&
|
|
1088
|
+
((event.recoveryTarget == "embedded" && event.recoveredHash == nil) ||
|
|
1089
|
+
(event.recoveryTarget == "previous" &&
|
|
1090
|
+
event.recoveredHash.map(isCanonicalHash) == true))
|
|
1091
|
+
}
|
|
1092
|
+
}
|
|
1093
|
+
|
|
1094
|
+
private static func eventDictionary(_ event: BundleDropStartupRecoveryEvent) -> [String: Any] {
|
|
1095
|
+
var result: [String: Any] = [
|
|
1096
|
+
"id": event.id,
|
|
1097
|
+
"failedHash": event.failedHash,
|
|
1098
|
+
"recoveryTarget": event.recoveryTarget,
|
|
1099
|
+
"crashCount": event.crashCount,
|
|
1100
|
+
"reason": event.reason,
|
|
1101
|
+
"failedAt": event.failedAt,
|
|
1102
|
+
]
|
|
1103
|
+
if let recoveredHash = event.recoveredHash {
|
|
1104
|
+
result["recoveredHash"] = recoveredHash
|
|
1105
|
+
}
|
|
1106
|
+
return result
|
|
1107
|
+
}
|
|
1108
|
+
}
|