1use super::{
16 atomic_file::{self, exists},
17 bootstrap::{self, BootstrapLease},
18 creation, device_reset,
19 file_lock::FileLock,
20 lock,
21 protection::Protection,
22 settings, BootstrapDirectoryError, BootstrapStore, DeviceReset, DirectoryCreationError,
23 FileError, Registration, ReplacedBy, ReplacementPhase, ReplacementRecord, StoreDir,
24 StoreDirAccess, StoreLock, StoreLockError,
25};
26use crate::id_source::{IdSource, StoreId};
27use crate::locks::lock_unpoisoned;
28use std::{
29 fs, io,
30 path::{Path, PathBuf},
31 sync::Mutex,
32};
33
34pub struct ReplacementStore {
38 _closing: lock::StoreClosingGuard,
41 path: PathBuf,
42 id: StoreId,
43 reset: DeviceReset,
44 by: ReplacedBy,
45 registration: Registration,
48 lease: BootstrapLease,
49 writer: Mutex<Option<StoreLock>>,
51 readers: Mutex<Option<FileLock>>,
54 record: Mutex<Option<ReplacementRecord>>,
56 loading: Mutex<Option<BootstrapStore>>,
59 protection: Protection,
60 bugs: crate::task::BugSinkRef,
61}
62
63impl ReplacementStore {
64 pub fn device_reset(&self) -> DeviceReset {
66 self.reset
67 }
68
69 pub fn registration(&self) -> Registration {
71 self.registration
72 }
73
74 pub fn is_swapped(&self) -> bool {
76 lock_unpoisoned(&self.loading).is_none()
77 }
78
79 pub fn directory(&self) -> StoreDir {
82 match &*lock_unpoisoned(&self.loading) {
83 Some(loading) => loading.directory(),
84 None => StoreDir::bootstrapping(
85 self.path.clone(),
86 self.id,
87 self.lease.instance(),
88 self.protection,
89 self.bugs.clone(),
90 ),
91 }
92 }
93
94 pub fn discarded_database_path(&self) -> PathBuf {
97 match &*lock_unpoisoned(&self.loading) {
98 Some(_) => self.path.join(super::directory::DATABASE),
99 None => device_reset::discarded_database(&self.path, self.reset.old_device),
100 }
101 }
102
103 pub fn is_recorded(&self) -> bool {
105 lock_unpoisoned(&self.record).is_some()
106 }
107
108 pub fn record(&self, name: String) -> Result<(), BootstrapDirectoryError> {
115 let mut recorded = lock_unpoisoned(&self.record);
116 if recorded.is_some() {
117 return Ok(());
118 }
119 let readers = self.exclude_readers()?;
120 let record = ReplacementRecord {
121 reset: self.reset,
122 by: self.by,
123 registration: self.registration,
124 name,
125 phase: ReplacementPhase::Registering,
126 };
127 let kept =
128 device_reset::record(&self.path, &record).map_err(DirectoryCreationError::from)?;
129 *lock_unpoisoned(&self.readers) = Some(readers);
130 *recorded = Some(kept);
131 Ok(())
132 }
133
134 pub fn swap(&self, name: String) -> Result<(), BootstrapDirectoryError> {
142 let mut loading = lock_unpoisoned(&self.loading);
143 if loading.is_none() {
144 return Ok(());
145 }
146 let held = lock_unpoisoned(&self.readers).take();
148 let _readers = match held {
149 Some(readers) => readers,
150 None => self.exclude_readers()?,
151 };
152 let recorded = lock_unpoisoned(&self.record).clone();
153 let record = match recorded {
154 Some(record) => record,
155 None => device_reset::record(
156 &self.path,
157 &ReplacementRecord {
158 reset: self.reset,
159 by: self.by,
160 registration: self.registration,
161 name,
162 phase: ReplacementPhase::Swapping,
163 },
164 )
165 .map_err(DirectoryCreationError::from)?,
166 };
167 device_reset::swapping(&self.path, &record).map_err(DirectoryCreationError::from)?;
168 device_reset::forward(&self.path, self.id, self.reset)?;
169 drop(loading.take());
170 self.release_writer();
171 Ok(())
172 }
173
174 pub fn abandon(self) -> Result<(), BootstrapDirectoryError> {
181 assert!(!self.is_swapped(), "only an unswapped replacement is abandoned");
182 device_reset::finish(&self.path)?;
183 lock_unpoisoned(&self.record).take();
184 lock_unpoisoned(&self.readers).take();
185 self.cancel()
186 }
187
188 fn exclude_readers(&self) -> Result<FileLock, StoreLockError> {
189 lock::exclude_readers(&self.path, self.id)
190 }
191
192 pub fn discarded_device_name(&self) -> String {
195 device_reset::archive_name(self.reset.old_device)
196 }
197
198 pub fn publish(&self) -> Result<(), BootstrapDirectoryError> {
203 assert!(self.is_swapped(), "publication follows the swap");
204 remove_area(&self.path)?;
205 let published = |source: io::Error| -> BootstrapDirectoryError {
206 DirectoryCreationError::Published { id: self.id, source }.into()
207 };
208 let result = bootstrap::remove_marker(&self.path, published);
209 self.lease.release();
210 result?;
211 device_reset::finish(&self.path).map_err(|error| published(io::Error::other(error)))
212 }
213
214 pub fn cancel(self) -> Result<(), BootstrapDirectoryError> {
217 assert!(!self.is_recorded(), "a recorded replacement only moves forward");
218 let loading = lock_unpoisoned(&self.loading)
219 .take()
220 .expect("only an unswapped replacement is cancelled");
221 loading.cancel()?;
222 drop(loading);
223 Ok(remove_area(&self.path)?)
224 }
225
226 fn release_writer(&self) {
227 lock_unpoisoned(&self.writer).take();
228 }
229}
230
231fn remove_area(directory: &Path) -> Result<(), FileError> {
232 let area = directory.join(device_reset::AREA);
233 if exists("inspect replacement area", &area)? {
234 fs::remove_dir_all(&area)
235 .map_err(|source| FileError::at("remove replacement area", &area, source))?;
236 atomic_file::sync_publication(&area)?;
237 }
238 Ok(())
239}
240
241pub(super) async fn begin(
245 root: &Path,
246 id: StoreId,
247 by: ReplacedBy,
248 registration: Registration,
249 ids: &dyn IdSource,
250 protection: Protection,
251 bugs: crate::task::BugSinkRef,
252) -> Result<ReplacementStore, BootstrapDirectoryError> {
253 let root = fs::canonicalize(root)
254 .map_err(|source| FileError::at("resolve store layout", root, source))?;
255 let path = root.join(id.to_string());
256 let lock = lock::acquire_bootstrap(&path, id, &bugs).await?;
257 let closing = lock.closing_guard();
258 let lease = BootstrapLease::new(lock);
259 let writer = lock::acquire_for_open(&path, id, &bugs).await?;
261 let current = settings::read(&path, id).map_err(DirectoryCreationError::Settings)?;
262 if super::deletion::read(&path)?.is_some() {
265 return Err(StoreLockError::DeletionUnfinished(id).into());
266 }
267 let pending = bootstrap::is_pending(&path)?;
268 let recorded = match device_reset::read(&path)? {
269 Some(record) if !pending && current.device_id == record.reset.new_device => {
272 device_reset::finish(&path)?;
273 None
274 }
275 recorded => recorded,
276 };
277 match &recorded {
278 Some(record) if record.by != by => {
281 return Err(StoreLockError::ReplacementUnfinished { store: id, by: record.by }.into())
282 }
283 None if pending => return Err(StoreLockError::BootstrapPending(id).into()),
284 _ => {}
285 }
286 protection.apply(&path)?;
289 let (reset, loading, readers) = match &recorded {
290 Some(record) if record.phase == ReplacementPhase::Swapping => {
292 let _readers = lock::exclude_readers(&path, id)?;
293 device_reset::forward(&path, id, record.reset)?;
294 (record.reset, None, None)
295 }
296 Some(record) => {
299 let readers = lock::exclude_readers(&path, id)?;
300 let area = path.join(device_reset::AREA);
301 let loading_path = device_reset::loading(&path, id);
302 if !exists("inspect recorded replacement", &loading_path)? {
303 return Err(FileError::at(
304 "resume a recorded replacement",
305 &loading_path,
306 io::Error::new(
307 io::ErrorKind::NotFound,
308 "the recorded replacement's installation is missing",
309 ),
310 )
311 .into());
312 }
313 let loading =
314 bootstrap::reserve_bootstrap_directory(&area, id, ids, protection, bugs.clone())
315 .await?;
316 let new =
317 loading.directory().settings().map_err(DirectoryCreationError::Settings)?.device_id;
318 if new != record.reset.new_device {
319 return Err(FileError::at(
320 "resume a recorded replacement",
321 &loading_path,
322 io::Error::new(
323 io::ErrorKind::InvalidData,
324 "the loaded installation is not the recorded fresh device",
325 ),
326 )
327 .into());
328 }
329 (record.reset, Some(loading), Some(readers))
330 }
331 None => {
332 let area = path.join(device_reset::AREA);
333 if !exists("inspect loading replacement", &device_reset::loading(&path, id))? {
335 remove_area(&path)?;
336 }
337 creation::create_directory(&area)
338 .map_err(|source| FileError::at("create replacement area", &area, source))?;
339 let loading =
340 bootstrap::reserve_bootstrap_directory(&area, id, ids, protection, bugs.clone())
341 .await?;
342 let new =
343 loading.directory().settings().map_err(DirectoryCreationError::Settings)?.device_id;
344 (DeviceReset { old_device: current.device_id, new_device: new }, Some(loading), None)
345 }
346 };
347 let registration = recorded.as_ref().map_or(registration, |record| record.registration);
349 let writer = loading.is_some().then_some(writer);
351 Ok(ReplacementStore {
352 _closing: closing,
353 path,
354 id,
355 reset,
356 by,
357 registration,
358 lease,
359 writer: Mutex::new(writer),
360 readers: Mutex::new(readers),
361 record: Mutex::new(recorded),
362 loading: Mutex::new(loading),
363 protection,
364 bugs,
365 })
366}
367
368#[cfg(test)]
369#[path = "replacement_tests.rs"]
370mod tests;