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. ExclusiveLock - Only one process can retain exclusive lock of the file.
2. SharedLock - Can retain the general lock on the given file more than one process.

Use

1. LockFile

    extern crate cluFlock;
   
    use cluFlock::Flock;
    use std::fs::File;
   
    fn main() {
    	let file = File::create("/tmp/1").unwrap();
   
    	let lock = file.exclusive_lock();
    	//Only one process can retain exclusive lock of the file.
   
    	println!("{:?}", lock);
   
    	drop(lock);
    }
   

2. TryLockFile

    extern crate cluFlock;
   
    use cluFlock::Flock;
    use std::fs::File;
    use std::time::Duration;
   
    fn main() {
    	let file = match File::create("/tmp/ulin.lock") {
    		Ok(a) => a,
    		Err(e) => panic!("Panic, err create file {:?}", e),
    	};
   
    	println!("Try_Exclusive_Lock, {:?}", file);
    	let lock = match file.try_exclusive_lock() {
    		//Success, we blocked the file.
    		Ok(Some(lock)) => {
    			println!("File {:?} successfully locked.", file);
    			lock
    		},
   
    		//File already locked.
    		Ok(None) => {
    			println!("File {:?} already locked.", file);
   
    			println!("!Exclusive_Lock, {:?}", file);
    			//Lock the current thread to such an extent until your file is unlocked.
    			file.exclusive_lock().unwrap()
    		},
   
    		Err(e) => panic!("Panic, err lock file {:?}", e)
   
    	};
   
    	println!("Sleep, 5s");
    	::std::thread::sleep(Duration::from_secs(5));
   
    	println!("Unlock, {:?}", file);
    	drop(lock);
    }
   

License

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

Licensed under the Apache License, Version 2.0