1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

use libc::{LOCK_EX, LOCK_NB, LOCK_UN};
use std::fs::{File, OpenOptions};
use std::io;
use std::os::unix::io::{AsRawFd, RawFd};
use std::path::Path;

use crate::error::*;

#[derive(Debug)]
pub(crate) struct RawNamedLock {
    lock_file: File,
}

impl RawNamedLock {
    pub(crate) fn create(name: &str) -> Result<RawNamedLock> {
        let lock_path = Path::new("/tmp").join(format!("{}.lock", name));

        let lock_file = OpenOptions::new()
            .write(true)
            .create_new(true)
            .open(&lock_path)
            .or_else(|_| OpenOptions::new().write(true).open(&lock_path))
            .map_err(|_| Error::CreateFailed)?;

        Ok(RawNamedLock {
            lock_file,
        })
    }

    pub(crate) fn try_lock(&self) -> Result<()> {
        unsafe { flock(self.lock_file.as_raw_fd(), LOCK_EX | LOCK_NB) }
    }

    pub(crate) fn lock(&self) -> Result<()> {
        unsafe { flock(self.lock_file.as_raw_fd(), LOCK_EX) }
    }

    pub(crate) fn unlock(&self) -> Result<()> {
        unsafe { flock(self.lock_file.as_raw_fd(), LOCK_UN) }
    }
}

unsafe fn flock(fd: RawFd, operation: i32) -> Result<()> {
    loop {
        let rc = libc::flock(fd, operation);

        if rc < 0 {
            let err = io::Error::last_os_error();

            if err.kind() == io::ErrorKind::Interrupted {
                continue;
            } else if err.kind() == io::ErrorKind::WouldBlock {
                return Err(Error::WouldBlock);
            } else if (operation & LOCK_EX) == LOCK_EX {
                return Err(Error::LockFailed);
            } else if (operation & LOCK_UN) == LOCK_UN {
                return Err(Error::UnlockFailed);
            }
        }

        break;
    }

    Ok(())
}