1. 1//! Filesystem writes that either land completely or not at all.
2. 2//!
3. 3//! Every install and update writes through here. A partial write to an
4. 4//! executable or a manifest leaves an install that reports itself healthy
5. 5//! while being unrunnable, which is the failure mode hardest to diagnose
6. 6//! after the fact.
7. 7
8. 8use std::path::Path;
9. 9
10. 10/// Write bytes to `path` via a temporary file in the same directory, then
11. 11/// rename. The rename is atomic within a filesystem, so a reader sees
12. 12/// either the old contents or the new ones.
13. 13pub fn write(path: &Path, bytes: &[u8]) -> Result<(), String> {
14. 14 let parent = path
15. 15 .parent()
16. 16 .ok_or_else(|| format!("{} has no parent directory", path.display()))?;
17. 17 std::fs::create_dir_all(parent).map_err(|e| format!("mkdir {}: {e}", parent.display()))?;
18. 18 // Unique per process so two concurrent writers cannot share a temp
19. 19 // file and interleave their bytes.
20. 20 let tmp = parent.join(format!(
21. 21 ".{}.{}.tmp",
22. 22 path.file_name()
23. 23 .and_then(|n| n.to_str())
24. 24 .unwrap_or("vak-write"),
25. 25 std::process::id()
26. 26 ));
27. 27 let result = (|| {
28. 28 std::fs::write(&tmp, bytes).map_err(|e| format!("write {}: {e}", tmp.display()))?;
29. 29 std::fs::rename(&tmp, path).map_err(|e| format!("rename into {}: {e}", path.display()))
30. 30 })();
31. 31 if result.is_err() {
32. 32 let _ = std::fs::remove_file(&tmp);
33. 33 }
34. 34 result
35. 35}
36. 36
37. 37/// Write bytes and mark the result executable.
38. 38pub fn write_executable(path: &Path, bytes: &[u8]) -> Result<(), String> {
39. 39 write(path, bytes)?;
40. 40 set_executable(path)
41. 41}
42. 42
43. 43pub fn set_executable(path: &Path) -> Result<(), String> {
44. 44 #[cfg(unix)]
45. 45 {
46. 46 use std::os::unix::fs::PermissionsExt as _;
47. 47 std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o755))
48. 48 .map_err(|e| format!("chmod {}: {e}", path.display()))?;
49. 49 }
50. 50 #[cfg(not(unix))]
51. 51 let _ = path;
52. 52 Ok(())
53. 53}
54. 54
55. 55/// Recursively copy a directory tree, each file written atomically.
56. 56pub fn copy_dir(src: &Path, dst: &Path) -> Result<(), String> {
57. 57 std::fs::create_dir_all(dst).map_err(|e| format!("mkdir {}: {e}", dst.display()))?;
58. 58 for entry in std::fs::read_dir(src).map_err(|e| format!("read dir {}: {e}", src.display()))? {
59. 59 let entry = entry.map_err(|e| format!("dir entry under {}: {e}", src.display()))?;
60. 60 let ty = entry
61. 61 .file_type()
62. 62 .map_err(|e| format!("file type {}: {e}", entry.path().display()))?;
63. 63 let target = dst.join(entry.file_name());
64. 64 if ty.is_dir() {
65. 65 copy_dir(&entry.path(), &target)?;
66. 66 } else {
67. 67 let bytes = std::fs::read(entry.path())
68. 68 .map_err(|e| format!("read {}: {e}", entry.path().display()))?;
69. 69 write(&target, &bytes)?;
70. 70 }
71. 71 }
72. 72 Ok(())
73. 73}
74. 74
75. 75#[cfg(test)]
76. 76#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
77. 77mod tests {
78. 78 use super::*;
79. 79
80. 80 #[test]
81. 81 fn write_replaces_content_and_leaves_no_temp_behind() {
82. 82 let dir = tempfile::tempdir().unwrap();
83. 83 let f = dir.path().join("f.json");
84. 84 write(&f, b"one").unwrap();
85. 85 write(&f, b"two").unwrap();
86. 86 assert_eq!(std::fs::read_to_string(&f).unwrap(), "two");
87. 87 let leftovers: Vec<_> = std::fs::read_dir(dir.path())
88. 88 .unwrap()
89. 89 .filter_map(Result::ok)
90. 90 .filter(|e| e.file_name().to_string_lossy().ends_with(".tmp"))
91. 91 .collect();
92. 92 assert!(leftovers.is_empty(), "temp files must not survive a write");
93. 93 }
94. 94
95. 95 #[test]
96. 96 fn executable_bit_is_set_on_a_written_binary() {
97. 97 let dir = tempfile::tempdir().unwrap();
98. 98 let dst = dir.path().join("nested").join("dst");
99. 99 write_executable(&dst, b"#!/bin/sh\n").unwrap();
100. 100 #[cfg(unix)]
101. 101 {
102. 102 use std::os::unix::fs::PermissionsExt as _;
103. 103 let mode = std::fs::metadata(&dst).unwrap().permissions().mode();
104. 104 assert_eq!(mode & 0o111, 0o111);
105. 105 }
106. 106 }
107. 107
108. 108 #[test]
109. 109 fn copy_dir_reproduces_a_nested_tree() {
110. 110 let dir = tempfile::tempdir().unwrap();
111. 111 let src = dir.path().join("src");
112. 112 std::fs::create_dir_all(src.join("a/b")).unwrap();
113. 113 std::fs::write(src.join("top.txt"), b"top").unwrap();
114. 114 std::fs::write(src.join("a/b/deep.txt"), b"deep").unwrap();
115. 115 let dst = dir.path().join("dst");
116. 116 copy_dir(&src, &dst).unwrap();
117. 117 assert_eq!(std::fs::read_to_string(dst.join("top.txt")).unwrap(), "top");
118. 118 assert_eq!(
119. 119 std::fs::read_to_string(dst.join("a/b/deep.txt")).unwrap(),
120. 120 "deep"
121. 121 );
122. 122 }
123. 123}
124. 124