file_locking.rs

pub mod errors;
pub mod file_ext;

#[cfg(unix)]
mod unix;

#[cfg(windows)]
mod windows;

pub use errors::{ Error, Result };
pub use file_ext::{ FileExt };

#[cfg(test)]
mod tests {
	use super::*;

	use std::fs::{ File, self };
	use std::path::{ Path, PathBuf };

	struct TestFile {
		path: PathBuf,
		file: File,
	}

	impl TestFile {
		fn new<P: AsRef<Path>>(path: P) -> Result<TestFile> {
			let path = path.as_ref();

			let file = File::options()
				.create_new(true)
				.write(true)
				.open(path)?;

			Ok(TestFile {
				path: path.to_path_buf(),
				file,
			})
		}
	}

	impl Drop for TestFile {
		fn drop(&mut self) {
			let _ = fs::remove_file(&self.path);
		}
	}

	#[test]
	fn lock_shared_works() {
		const TEST_FILE_PATH: &str = "test_lock_shared.txt";
		let f = TestFile::new(TEST_FILE_PATH).expect("File should be created and opened");
		let _guard = f.file.lock_shared().expect("Shared file lock should be obtained");
	}

	#[test]
	fn lock_exclusive_works() {
		const TEST_FILE_PATH: &str = "test_lock_exclusive.txt";
		let f = TestFile::new(TEST_FILE_PATH).expect("File should be created and opened");
		let _guard = f.file.lock_exclusive().expect("Exclusive file lock should be obtained");
	}

	#[test]
	fn try_lock_shared_works() {
		const TEST_FILE_PATH: &str = "test_try_lock_shared.txt";
		let f = TestFile::new(TEST_FILE_PATH).expect("File should be created and opened");
		let _guard = f.file.try_lock_shared().expect("Shared file lock should be obtained");
	}

	#[test]
	fn try_lock_exclusive_works() {
		const TEST_FILE_PATH: &str = "test_try_lock_exclusive.txt";
		let f = TestFile::new(TEST_FILE_PATH).expect("File should be created and opened");
		let _guard = f.file.try_lock_shared().expect("Shared file lock should be obtained");
	}

	#[test]
	fn try_lock_exclusive_does_not_block() {
		const TEST_FILE_PATH: &str = "test_try_lock_exclusive_does_not_block.txt";
		let f = TestFile::new(TEST_FILE_PATH).expect("File should be created and opened");
		let _guard = f.file.try_lock_exclusive().expect("First exclusive file lock should be obtained");
		let result = f.file.try_lock_exclusive();

		match result {
			Ok(_) => panic!("Second exclusive file lock should not be obtained"),
			Err(Error::AlreadyLocked) => {},
			Err(_) => panic!("Result of trying to obtain a second exclusive file lock should be Error::AlreadyLocked"),
		}
	}
}