_ Git - rust-lightning/blob - lightning-persister/src/util.rs

   1
   2 #[cfg(target_os = "windows")]
   3 extern crate winapi;
   4
   5 use std::fs;
   6 use std::path::{Path, PathBuf};
   7 #[cfg(target_os = "windows")]
   8         use {
   9                 std::ffi::OsStr,
  10                 std::os::windows::ffi::OsStrExt
  11                 };
  12 #[cfg(not(target_os = "windows"))]
  13 use std::os::unix::io::AsRawFd;
  14
  15 pub(crate) trait DiskWriteable {
  16         fn write_to_file(&self, writer: &mut fs::File) -> Result<(), std::io::Error>;
  17 }
  18
  19 pub(crate) fn get_full_filepath(filepath: String, filename: String) -> String {
  20         let mut path = PathBuf::from(filepath);
  21         path.push(filename);
  22         path.to_str().unwrap().to_string()
  23 }
  24 #[cfg(target_os = "windows")]
  25 macro_rules! call {
  26         ($e: expr) => (
  27                 if $e != 0 {
  28                         return Ok(())
  29                 } else {
  30                         return Err(std::io::Error::last_os_error())
  31                 }
  32         )
  33 }
  34
  35 #[cfg(target_os = "windows")]
  36 fn path_to_windows_str<T: AsRef<OsStr>>(x: T) -> Vec<winapi::shared::ntdef::WCHAR> {
  37         x.as_ref().encode_wide().chain(Some(0)).collect()
  38 }
  39
  40 #[allow(bare_trait_objects)]
  41 pub(crate) fn write_to_file<D: DiskWriteable>(path: String, filename: String, data: &D) -> std::io::Result<()> {
  42         println!("VMW: creating dir");
  43         fs::create_dir_all(path.clone())?;
  44         println!("VMW: created dir");
  45
  46         // Do a crazy dance with lots of fsync()s to be overly cautious here...
  47         // We never want to end up in a state where we've lost the old data, or end up using the
  48         // old data on power loss after we've returned.
  49         // The way to atomically write a file on Unix platforms is:
  50         // open(tmpname), write(tmpfile), fsync(tmpfile), close(tmpfile), rename(), fsync(dir)
  51         let filename_with_path = get_full_filepath(path.clone(), filename);
  52         let tmp_filename = format!("{}.tmp", filename_with_path);
  53
  54         {
  55                 // Note that going by rust-lang/rust@d602a6b, on MacOS it is only safe to use
  56                 // rust stdlib 1.36 or higher.
  57                 println!("VMW: about to create file");
  58                 let mut f = fs::File::create(&tmp_filename)?;
  59                 println!("VMW: created file");
  60                 data.write_to_file(&mut f)?;
  61                 println!("VMW: about to sync all");
  62                 f.sync_all()?;
  63                 println!("VMW: sync'd all");
  64         }
  65         // Fsync the parent directory on Unix.
  66         #[cfg(not(target_os = "windows"))]
  67         {
  68                 fs::rename(&tmp_filename, &filename_with_path)?;
  69                 let path = Path::new(&filename_with_path).parent().unwrap();
  70                 let dir_file = fs::OpenOptions::new().read(true).open(path)?;
  71                 unsafe { libc::fsync(dir_file.as_raw_fd()); }
  72         }
  73         std::thread::sleep(std::time::Duration::new(5, 0));
  74         #[cfg(target_os = "windows")]
  75         {
  76                 println!("VMW: entries in dir:");
  77                 let dir_perms = fs::metadata(path.clone()).unwrap().permissions();
  78                 println!("VMW: dir perms: {:?}, readonly: {}", dir_perms, dir_perms.readonly());
  79                 let dir = PathBuf::from(path.clone());
  80                 for entry in fs::read_dir(dir).unwrap() {
  81                         let entry = entry.unwrap();
  82                         let metadata = entry.metadata().unwrap();
  83                         println!("VMW: entry in dir: {:?}, perms in entry: {:?}, readonly: {}", entry.path(), metadata.permissions(), metadata.permissions().readonly());
  84                 }
  85
  86                 // let mut dir_perms = fs::metadata(path.clone()).unwrap().permissions();
  87                 // dir_perms.set_readonly(false);
  88                 // if let Ok(metadata) = fs::metadata(filename_with_path.clone()) {
  89                 //      let mut perms = metadata.permissions();
  90                 //      perms.set_readonly(false);
  91                 // }
  92     // // let mut perms = fs::metadata(filename_with_path.clone())?.permissions();
  93     // let mut tmp_perms = fs::metadata(tmp_filename.clone())?.permissions();
  94                 // tmp_perms.set_readonly(false);
  95                 // println!("VMW: about to rename");
  96                 // let src = PathBuf::from(tmp_filename);
  97                 // let dst = PathBuf::from(filename_with_path);
  98                 fs::rename(&tmp_filename.clone(), &filename_with_path.clone())?;
  99                 // call!(unsafe {winapi::um::winbase::MoveFileExW(
 100                 //      path_to_windows_str(src).as_ptr(), path_to_windows_str(dst).as_ptr(),
 101                 //      winapi::um::winbase::MOVEFILE_WRITE_THROUGH | winapi::um::winbase::MOVEFILE_REPLACE_EXISTING
 102                 // )});
 103                 println!("VMW: renamed");
 104         }
 105         Ok(())
 106 }
 107
 108 #[cfg(test)]
 109 mod tests {
 110         use super::{DiskWriteable, get_full_filepath, write_to_file};
 111         use std::fs;
 112         use std::io;
 113         use std::io::Write;
 114
 115         struct TestWriteable{}
 116         impl DiskWriteable for TestWriteable {
 117                 fn write_to_file(&self, writer: &mut fs::File) -> Result<(), io::Error> {
 118                         writer.write_all(&[42; 1])
 119                 }
 120         }
 121
 122         // Test that if the persister's path to channel data is read-only, writing
 123         // data to it fails. Windows ignores the read-only flag for folders, so this
 124         // test is Unix-only.
 125         #[cfg(not(target_os = "windows"))]
 126         #[test]
 127         fn test_readonly_dir() {
 128                 let test_writeable = TestWriteable{};
 129                 let filename = "test_readonly_dir_persister_filename".to_string();
 130                 let path = "test_readonly_dir_persister_dir";
 131                 fs::create_dir_all(path.to_string()).unwrap();
 132                 let mut perms = fs::metadata(path.to_string()).unwrap().permissions();
 133                 perms.set_readonly(true);
 134                 fs::set_permissions(path.to_string(), perms).unwrap();
 135                 match write_to_file(path.to_string(), filename, &test_writeable) {
 136                         Err(e) => assert_eq!(e.kind(), io::ErrorKind::PermissionDenied),
 137                         _ => panic!("Unexpected error message")
 138                 }
 139         }
 140
 141         // Test failure to rename in the process of atomically creating a channel
 142         // monitor's file. We induce this failure by making the `tmp` file a
 143         // directory.
 144         // Explanation: given "from" = the file being renamed, "to" = the
 145         // renamee that already exists: Windows should fail because it'll fail
 146         // whenever "to" is a directory, and Unix should fail because if "from" is a
 147         // file, then "to" is also required to be a file.
 148         #[test]
 149         fn test_rename_failure() {
 150                 let test_writeable = TestWriteable{};
 151                 let filename = "test_rename_failure_filename";
 152                 let path = "test_rename_failure_dir";
 153                 // Create the channel data file and make it a directory.
 154                 fs::create_dir_all(get_full_filepath(path.to_string(), filename.to_string())).unwrap();
 155                 match write_to_file(path.to_string(), filename.to_string(), &test_writeable) {
 156                         Err(e) => {
 157                                 #[cfg(not(target_os = "windows"))]
 158                                 assert_eq!(e.kind(), io::ErrorKind::Other);
 159                                 #[cfg(target_os = "windows")]
 160                                 assert_eq!(e.kind(), io::ErrorKind::PermissionDenied);
 161                         }
 162                         _ => panic!("Unexpected error message")
 163                 }
 164                 fs::remove_dir_all(path).unwrap();
 165         }
 166
 167         #[test]
 168         fn test_diskwriteable_failure() {
 169                 struct FailingWriteable {}
 170                 impl DiskWriteable for FailingWriteable {
 171                         fn write_to_file(&self, _writer: &mut fs::File) -> Result<(), std::io::Error> {
 172                                 Err(std::io::Error::new(std::io::ErrorKind::Other, "expected failure"))
 173                         }
 174                 }
 175
 176                 let filename = "test_diskwriteable_failure";
 177                 let path = "test_diskwriteable_failure_dir";
 178                 let test_writeable = FailingWriteable{};
 179                 match write_to_file(path.to_string(), filename.to_string(), &test_writeable) {
 180                         Err(e) => {
 181                                 assert_eq!(e.kind(), std::io::ErrorKind::Other);
 182                                 assert_eq!(e.get_ref().unwrap().to_string(), "expected failure");
 183                         },
 184                         _ => panic!("unexpected result")
 185                 }
 186                 fs::remove_dir_all(path).unwrap();
 187         }
 188
 189         // Test failure to create the temporary file in the persistence process.
 190         // We induce this failure by having the temp file already exist and be a
 191         // directory.
 192         #[test]
 193         fn test_tmp_file_creation_failure() {
 194                 let test_writeable = TestWriteable{};
 195                 let filename = "test_tmp_file_creation_failure_filename".to_string();
 196                 let path = "test_tmp_file_creation_failure_dir".to_string();
 197
 198                 // Create the tmp file and make it a directory.
 199                 let tmp_path = get_full_filepath(path.clone(), format!("{}.tmp", filename.clone()));
 200                 fs::create_dir_all(tmp_path).unwrap();
 201                 match write_to_file(path, filename, &test_writeable) {
 202                         Err(e) => {
 203                                 #[cfg(not(target_os = "windows"))]
 204                                 assert_eq!(e.kind(), io::ErrorKind::Other);
 205                                 #[cfg(target_os = "windows")]
 206                                 assert_eq!(e.kind(), io::ErrorKind::PermissionDenied);
 207                         }
 208                         _ => panic!("Unexpected error message")
 209                 }
 210         }
 211 }