X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-persister%2Fsrc%2Futil.rs;h=4adbb33e5b26fd886fb64d05d3d315efd3f28b16;hb=ccbf3302a756ac425f17f52f868c54862390cb83;hp=0e3999883fb652a2fe511de8f13278f222ffd71b;hpb=36eaccc60782d897ce820aacf8035568ea5896d5;p=rust-lightning diff --git a/lightning-persister/src/util.rs b/lightning-persister/src/util.rs index 0e399988..4adbb33e 100644 --- a/lightning-persister/src/util.rs +++ b/lightning-persister/src/util.rs @@ -1,58 +1,94 @@ +#[cfg(target_os = "windows")] +extern crate winapi; + use std::fs; -use std::path::{Path, PathBuf}; +use std::path::PathBuf; +use std::io::BufWriter; #[cfg(not(target_os = "windows"))] use std::os::unix::io::AsRawFd; -pub(crate) trait DiskWriteable { - fn write_to_file(&self, writer: &mut fs::File) -> Result<(), std::io::Error>; +use lightning::util::ser::Writeable; + +#[cfg(target_os = "windows")] +use { + std::ffi::OsStr, + std::os::windows::ffi::OsStrExt +}; + +#[cfg(target_os = "windows")] +macro_rules! call { + ($e: expr) => ( + if $e != 0 { + return Ok(()) + } else { + return Err(std::io::Error::last_os_error()) + } + ) } -pub fn get_full_filepath(filepath: String, filename: String) -> String { - let mut path = PathBuf::from(filepath); - path.push(filename); - path.to_str().unwrap().to_string() +#[cfg(target_os = "windows")] +fn path_to_windows_str>(path: T) -> Vec { + path.as_ref().encode_wide().chain(Some(0)).collect() } #[allow(bare_trait_objects)] -pub(crate) fn write_to_file(path: String, filename: String, data: &D) -> std::io::Result<()> { - fs::create_dir_all(path.clone())?; +pub(crate) fn write_to_file(dest_file: PathBuf, data: &W) -> std::io::Result<()> { + let mut tmp_file = dest_file.clone(); + tmp_file.set_extension("tmp"); + + let parent_directory = dest_file.parent().unwrap(); + fs::create_dir_all(parent_directory)?; // Do a crazy dance with lots of fsync()s to be overly cautious here... // We never want to end up in a state where we've lost the old data, or end up using the // old data on power loss after we've returned. // The way to atomically write a file on Unix platforms is: // open(tmpname), write(tmpfile), fsync(tmpfile), close(tmpfile), rename(), fsync(dir) - let filename_with_path = get_full_filepath(path, filename); - let tmp_filename = format!("{}.tmp", filename_with_path); - { // Note that going by rust-lang/rust@d602a6b, on MacOS it is only safe to use // rust stdlib 1.36 or higher. - let mut f = fs::File::create(&tmp_filename)?; - data.write_to_file(&mut f)?; - f.sync_all()?; + let mut buf = BufWriter::new(fs::File::create(&tmp_file)?); + data.write(&mut buf)?; + buf.into_inner()?.sync_all()?; } - fs::rename(&tmp_filename, &filename_with_path)?; // Fsync the parent directory on Unix. #[cfg(not(target_os = "windows"))] { - let path = Path::new(&filename_with_path).parent().unwrap(); - let dir_file = fs::OpenOptions::new().read(true).open(path)?; + fs::rename(&tmp_file, &dest_file)?; + let dir_file = fs::OpenOptions::new().read(true).open(parent_directory)?; unsafe { libc::fsync(dir_file.as_raw_fd()); } } + #[cfg(target_os = "windows")] + { + if dest_file.exists() { + unsafe {winapi::um::winbase::ReplaceFileW( + path_to_windows_str(dest_file).as_ptr(), path_to_windows_str(tmp_file).as_ptr(), std::ptr::null(), + winapi::um::winbase::REPLACEFILE_IGNORE_MERGE_ERRORS, + std::ptr::null_mut() as *mut winapi::ctypes::c_void, + std::ptr::null_mut() as *mut winapi::ctypes::c_void + )}; + } else { + call!(unsafe {winapi::um::winbase::MoveFileExW( + path_to_windows_str(tmp_file).as_ptr(), path_to_windows_str(dest_file).as_ptr(), + winapi::um::winbase::MOVEFILE_WRITE_THROUGH | winapi::um::winbase::MOVEFILE_REPLACE_EXISTING + )}); + } + } Ok(()) } #[cfg(test)] mod tests { - use super::{DiskWriteable, get_full_filepath, write_to_file}; + use lightning::util::ser::{Writer, Writeable}; + + use super::{write_to_file}; use std::fs; use std::io; - use std::io::Write; + use std::path::PathBuf; struct TestWriteable{} - impl DiskWriteable for TestWriteable { - fn write_to_file(&self, writer: &mut fs::File) -> Result<(), io::Error> { + impl Writeable for TestWriteable { + fn write(&self, writer: &mut W) -> Result<(), std::io::Error> { writer.write_all(&[42; 1]) } } @@ -70,7 +106,9 @@ mod tests { let mut perms = fs::metadata(path.to_string()).unwrap().permissions(); perms.set_readonly(true); fs::set_permissions(path.to_string(), perms).unwrap(); - match write_to_file(path.to_string(), filename, &test_writeable) { + let mut dest_file = PathBuf::from(path); + dest_file.push(filename); + match write_to_file(dest_file, &test_writeable) { Err(e) => assert_eq!(e.kind(), io::ErrorKind::PermissionDenied), _ => panic!("Unexpected error message") } @@ -79,25 +117,23 @@ mod tests { // Test failure to rename in the process of atomically creating a channel // monitor's file. We induce this failure by making the `tmp` file a // directory. - // Explanation: given "from" = the file being renamed, "to" = the - // renamee that already exists: Windows should fail because it'll fail - // whenever "to" is a directory, and Unix should fail because if "from" is a - // file, then "to" is also required to be a file. + // Explanation: given "from" = the file being renamed, "to" = the destination + // file that already exists: Unix should fail because if "from" is a file, + // then "to" is also required to be a file. + // TODO: ideally try to make this work on Windows again + #[cfg(not(target_os = "windows"))] #[test] fn test_rename_failure() { let test_writeable = TestWriteable{}; let filename = "test_rename_failure_filename"; let path = "test_rename_failure_dir"; + let mut dest_file = PathBuf::from(path); + dest_file.push(filename); // Create the channel data file and make it a directory. - fs::create_dir_all(get_full_filepath(path.to_string(), filename.to_string())).unwrap(); - match write_to_file(path.to_string(), filename.to_string(), &test_writeable) { - Err(e) => { - #[cfg(not(target_os = "windows"))] - assert_eq!(e.kind(), io::ErrorKind::Other); - #[cfg(target_os = "windows")] - assert_eq!(e.kind(), io::ErrorKind::PermissionDenied); - } - _ => panic!("Unexpected error message") + fs::create_dir_all(dest_file.clone()).unwrap(); + match write_to_file(dest_file, &test_writeable) { + Err(e) => assert_eq!(e.raw_os_error(), Some(libc::EISDIR)), + _ => panic!("Unexpected Ok(())") } fs::remove_dir_all(path).unwrap(); } @@ -105,8 +141,8 @@ mod tests { #[test] fn test_diskwriteable_failure() { struct FailingWriteable {} - impl DiskWriteable for FailingWriteable { - fn write_to_file(&self, _writer: &mut fs::File) -> Result<(), std::io::Error> { + impl Writeable for FailingWriteable { + fn write(&self, _writer: &mut W) -> Result<(), std::io::Error> { Err(std::io::Error::new(std::io::ErrorKind::Other, "expected failure")) } } @@ -114,7 +150,9 @@ mod tests { let filename = "test_diskwriteable_failure"; let path = "test_diskwriteable_failure_dir"; let test_writeable = FailingWriteable{}; - match write_to_file(path.to_string(), filename.to_string(), &test_writeable) { + let mut dest_file = PathBuf::from(path); + dest_file.push(filename); + match write_to_file(dest_file, &test_writeable) { Err(e) => { assert_eq!(e.kind(), std::io::ErrorKind::Other); assert_eq!(e.get_ref().unwrap().to_string(), "expected failure"); @@ -131,15 +169,16 @@ mod tests { fn test_tmp_file_creation_failure() { let test_writeable = TestWriteable{}; let filename = "test_tmp_file_creation_failure_filename".to_string(); - let path = "test_tmp_file_creation_failure_dir".to_string(); - - // Create the tmp file and make it a directory. - let tmp_path = get_full_filepath(path.clone(), format!("{}.tmp", filename.clone())); - fs::create_dir_all(tmp_path).unwrap(); - match write_to_file(path, filename, &test_writeable) { + let path = "test_tmp_file_creation_failure_dir"; + let mut dest_file = PathBuf::from(path); + dest_file.push(filename); + let mut tmp_file = dest_file.clone(); + tmp_file.set_extension("tmp"); + fs::create_dir_all(tmp_file).unwrap(); + match write_to_file(dest_file, &test_writeable) { Err(e) => { #[cfg(not(target_os = "windows"))] - assert_eq!(e.kind(), io::ErrorKind::Other); + assert_eq!(e.raw_os_error(), Some(libc::EISDIR)); #[cfg(target_os = "windows")] assert_eq!(e.kind(), io::ErrorKind::PermissionDenied); }