1 #[cfg(target_os = "windows")]
5 use std::path::{Path, PathBuf};
6 use std::io::{BufWriter, Write};
8 #[cfg(not(target_os = "windows"))]
9 use std::os::unix::io::AsRawFd;
11 #[cfg(target_os = "windows")]
14 std::os::windows::ffi::OsStrExt
17 pub(crate) trait DiskWriteable {
18 fn write_to_file<W: Write>(&self, writer: &mut W) -> Result<(), std::io::Error>;
21 pub(crate) fn get_full_filepath(mut filepath: PathBuf, filename: String) -> String {
22 filepath.push(filename);
23 filepath.to_str().unwrap().to_string()
26 #[cfg(target_os = "windows")]
32 return Err(std::io::Error::last_os_error())
37 #[cfg(target_os = "windows")]
38 fn path_to_windows_str<T: AsRef<OsStr>>(path: T) -> Vec<winapi::shared::ntdef::WCHAR> {
39 path.as_ref().encode_wide().chain(Some(0)).collect()
42 #[allow(bare_trait_objects)]
43 pub(crate) fn write_to_file<D: DiskWriteable>(path: PathBuf, filename: String, data: &D) -> std::io::Result<()> {
44 fs::create_dir_all(path.clone())?;
45 // Do a crazy dance with lots of fsync()s to be overly cautious here...
46 // We never want to end up in a state where we've lost the old data, or end up using the
47 // old data on power loss after we've returned.
48 // The way to atomically write a file on Unix platforms is:
49 // open(tmpname), write(tmpfile), fsync(tmpfile), close(tmpfile), rename(), fsync(dir)
50 let filename_with_path = get_full_filepath(path, filename);
51 let tmp_filename = format!("{}.tmp", filename_with_path.clone());
54 // Note that going by rust-lang/rust@d602a6b, on MacOS it is only safe to use
55 // rust stdlib 1.36 or higher.
56 let mut buf = BufWriter::new(fs::File::create(&tmp_filename)?);
57 data.write_to_file(&mut buf)?;
58 buf.into_inner()?.sync_all()?;
60 // Fsync the parent directory on Unix.
61 #[cfg(not(target_os = "windows"))]
63 fs::rename(&tmp_filename, &filename_with_path)?;
64 let path = Path::new(&filename_with_path).parent().unwrap();
65 let dir_file = fs::OpenOptions::new().read(true).open(path)?;
66 unsafe { libc::fsync(dir_file.as_raw_fd()); }
68 #[cfg(target_os = "windows")]
70 let src = PathBuf::from(tmp_filename.clone());
71 let dst = PathBuf::from(filename_with_path.clone());
72 if Path::new(&filename_with_path.clone()).exists() {
73 unsafe {winapi::um::winbase::ReplaceFileW(
74 path_to_windows_str(dst).as_ptr(), path_to_windows_str(src).as_ptr(), std::ptr::null(),
75 winapi::um::winbase::REPLACEFILE_IGNORE_MERGE_ERRORS,
76 std::ptr::null_mut() as *mut winapi::ctypes::c_void,
77 std::ptr::null_mut() as *mut winapi::ctypes::c_void
80 call!(unsafe {winapi::um::winbase::MoveFileExW(
81 path_to_windows_str(src).as_ptr(), path_to_windows_str(dst).as_ptr(),
82 winapi::um::winbase::MOVEFILE_WRITE_THROUGH | winapi::um::winbase::MOVEFILE_REPLACE_EXISTING
91 use super::{DiskWriteable, get_full_filepath, write_to_file};
95 use std::path::PathBuf;
97 struct TestWriteable{}
98 impl DiskWriteable for TestWriteable {
99 fn write_to_file<W: Write>(&self, writer: &mut W) -> Result<(), io::Error> {
100 writer.write_all(&[42; 1])
104 // Test that if the persister's path to channel data is read-only, writing
105 // data to it fails. Windows ignores the read-only flag for folders, so this
106 // test is Unix-only.
107 #[cfg(not(target_os = "windows"))]
109 fn test_readonly_dir() {
110 let test_writeable = TestWriteable{};
111 let filename = "test_readonly_dir_persister_filename".to_string();
112 let path = "test_readonly_dir_persister_dir";
113 fs::create_dir_all(path.to_string()).unwrap();
114 let mut perms = fs::metadata(path.to_string()).unwrap().permissions();
115 perms.set_readonly(true);
116 fs::set_permissions(path.to_string(), perms).unwrap();
117 match write_to_file(PathBuf::from(path.to_string()), filename, &test_writeable) {
118 Err(e) => assert_eq!(e.kind(), io::ErrorKind::PermissionDenied),
119 _ => panic!("Unexpected error message")
123 // Test failure to rename in the process of atomically creating a channel
124 // monitor's file. We induce this failure by making the `tmp` file a
126 // Explanation: given "from" = the file being renamed, "to" = the destination
127 // file that already exists: Unix should fail because if "from" is a file,
128 // then "to" is also required to be a file.
129 // TODO: ideally try to make this work on Windows again
130 #[cfg(not(target_os = "windows"))]
132 fn test_rename_failure() {
133 let test_writeable = TestWriteable{};
134 let filename = "test_rename_failure_filename";
135 let path = PathBuf::from("test_rename_failure_dir");
136 // Create the channel data file and make it a directory.
137 fs::create_dir_all(get_full_filepath(path.clone(), filename.to_string())).unwrap();
138 match write_to_file(path.clone(), filename.to_string(), &test_writeable) {
139 Err(e) => assert_eq!(e.raw_os_error(), Some(libc::EISDIR)),
140 _ => panic!("Unexpected Ok(())")
142 fs::remove_dir_all(path).unwrap();
146 fn test_diskwriteable_failure() {
147 struct FailingWriteable {}
148 impl DiskWriteable for FailingWriteable {
149 fn write_to_file<W: Write>(&self, _writer: &mut W) -> Result<(), std::io::Error> {
150 Err(std::io::Error::new(std::io::ErrorKind::Other, "expected failure"))
154 let filename = "test_diskwriteable_failure";
155 let path = PathBuf::from("test_diskwriteable_failure_dir");
156 let test_writeable = FailingWriteable{};
157 match write_to_file(path.clone(), filename.to_string(), &test_writeable) {
159 assert_eq!(e.kind(), std::io::ErrorKind::Other);
160 assert_eq!(e.get_ref().unwrap().to_string(), "expected failure");
162 _ => panic!("unexpected result")
164 fs::remove_dir_all(path).unwrap();
167 // Test failure to create the temporary file in the persistence process.
168 // We induce this failure by having the temp file already exist and be a
171 fn test_tmp_file_creation_failure() {
172 let test_writeable = TestWriteable{};
173 let filename = "test_tmp_file_creation_failure_filename".to_string();
174 let path = PathBuf::from("test_tmp_file_creation_failure_dir");
176 // Create the tmp file and make it a directory.
177 let tmp_path = get_full_filepath(path.clone(), format!("{}.tmp", filename.clone()));
178 fs::create_dir_all(tmp_path).unwrap();
179 match write_to_file(path, filename, &test_writeable) {
181 #[cfg(not(target_os = "windows"))]
182 assert_eq!(e.raw_os_error(), Some(libc::EISDIR));
183 #[cfg(target_os = "windows")]
184 assert_eq!(e.kind(), io::ErrorKind::PermissionDenied);
186 _ => panic!("Unexpected error message")