cluFlock

Control of lock of the file using the 'flock' functions.

Capabilities

1. Convenient and transparent trait of a call of locks.
2. Automatic unlocking of lock.

Locks

1. ExclusiveFlock - To establish exclusive blocking. Only one process can hold exclusive blocking of the file..
2. SharedFlock - Set a shared lock. A shared lock on a given file can hold more than one process.

Use

1. Exclusive LockFile

    extern crate cluFlock;
   
    use cluFlock::ToFlock;
    use std::fs::File;
    use std::io;
   
    fn main() -> Result<(), io::Error> {
    	let file_lock = File::create("/tmp/1")?.wait_exclusive_lock()?;
   
    	println!("{:?}", file_lock);
    	
    	drop(file_lock); //<-- unlock fn.
   
    	Ok( () )
    }
   

2. Exclusive LockClosure

    extern crate cluFlock;
   
    use std::io::Write;
    use cluFlock::ToFlock;
    use std::fs::File;
    use std::io;
   
    fn main() -> Result<(), io::Error> {
    	File::create("/tmp/1")?.wait_exclusive_lock_fn(|mut file| {
    		write!(file,  "Test.")
    	})??;
   
    	Ok( () )
    }
   

3. The temporary file for interprogram synchronization

    extern crate cluFlock;
   
    use cluFlock::ToFlock;
    use cluFlock::FileFlock;
    use std::io::ErrorKind::AlreadyExists;
    use std::path::Path;
    use std::fs;
    use std::io;
    use std::fs::OpenOptions;
   
    //Example
    //The temporary file for interprogram synchronization.
   
   
    #[derive(Debug)]
    pub struct MyLockFile<'a>(FileFlock, Option<&'a Path>);
   
    impl<'a> MyLockFile<'a> {
    	pub fn new(p: &'a Path) -> Result<Self, io::Error> {
    		let (lock, path) = match OpenOptions::new().write(true).create_new(true).open(p) {
    			Ok(file) => (file.wait_exclusive_lock()?, Some(p)),
    			Err(ref e) if e.kind() == AlreadyExists => {
    				let f = OpenOptions::new().read(true).open(p)?; 
   
    				let lock = f.try_exclusive_lock()?;
   
    				(lock, None)
    			},
    			Err(e) => return Err(e),
    		};
   
    		Ok( MyLockFile(lock, path) )
    	}
    }
   
    impl<'a> Drop for MyLockFile<'a> {
    	fn drop(&mut self) {
    		//Not obligatory action.
    		//
   
    		//Not to delete the file if it initially existed.
   
    		if let Some(path) = self.1 {
    			let _e = fs::remove_file(path);
    		}
    	}
    }
   
   
    pub fn main() -> Result<(), io::Error> {
    	let path = Path::new("/tmp/flock.lock");
    	println!("LockFile {:?}", path);
    	let lock_file = MyLockFile::new(path)?;
   
    	println!("OK! FileFlock {:?}", lock_file);
    	for a in 0..4 {
    		println!("Sleep {}", a);
    		::std::thread::sleep(::std::time::Duration::from_secs(1));
    	}
   
    	drop(lock_file);
   
    	Ok( () )
    }
   

License

Copyright 2018 #UlinProject Денис Котляров

Licensed under the Apache License, Version 2.0