Improve ergonomics around lock guard

[pronebird]

Hi,

First of all great crate, looks solid.

However I found that it becomes a bit difficult to integrate the crate because NamedLockGuard borrows from NamedLock, consider the following helper:

fn ensure_single_instance<'a>() -> anyhow::Result<NamedLockGuard<'a>> {
    let lock = NamedLock::create("my-unique-lock")?;
    lock.try_lock().map_err(|e| {
        if matches!(e, named_lock::Error::WouldBlock) {
            anyhow!("Another instance is already running.")
        } else {
            anyhow::Error::new(e).context("Couldn't acquire single instance lock.")
        }
    })
}

which doesn't compile and errors with:

16 |       lock.try_lock().map_err(|e| {
   |       ^---
   |       |
   |  _____`lock` is borrowed here
   | |
17 | |         if matches!(e, named_lock::Error::WouldBlock) {
18 | |             anyhow!("Another instance is already running.")
19 | |         } else {
20 | |             anyhow::Error::new(e).context("Couldn't acquire single instance lock.")
21 | |         }
22 | |     })
   | |______^ returns a value referencing data owned by the current function

Honestly I don't know how to untangle this and make it compile. Putting all that code into main() is not really an option for me since I don't return Result<> from main() since I don't want errors printed by default.

[pronebird]

Actually I found a workaround but it's still rather cumbersome to deal with locks because lock guards borrow from them? It would be great to have an owned implementation that could be passed around without dealing with borrow checker or lifetimes.

[oblique]

Internally I use parking_lot crate to workaround some other issues of the OS API. The parking_lot doesn't have owned implementation of their MutexGuard so I need to investigate a bit how I could implement this. I'm a bit busy these days but I will try to check it on my free time.

[oblique]

Ok, I just found ArcMutexGuard, so it is possible to make NamedLockGuard owned.

[oblique]

@pronebird I opened PR #9. Since internally NamedLock already uses Arc, I decided to break compatibility and remove lifetime instead of introducing a new type. What do you think about the changes?

[pronebird]

@oblique looks good. Just pulled it into my project and it worked great. I rewrote my code a bit into two stage rocket to benefit from early return but otherwise now I can hide all the guts of named_lock initialization into separate function.

fn main() -> ExitCode {
    if run().is_ok() {
        ExitCode::SUCCESS
    } else {
        ExitCode::FAILURE
    }
}

fn run() -> Result<()> {
    let _named_lock_guard = ensure_single_instance()?;
    // [redacted]
    Ok(())
}

fn ensure_single_instance() -> named_lock::Result<named_lock::NamedLockGuard> {
    named_lock::NamedLock::create("my-unique-lock")
        .and_then(|lock| lock.try_lock())
        .inspect_err(|err| match err {
            named_lock::Error::WouldBlock => {
                eprintln!("Another instance is already running");
            }
            e => {
                eprintln!("Couldn't acquire single instance lock: {}", e);
            }
        })
}

[oblique]

Thanks! I just merged the changes. I will migrate to windows-rs the next few days and then release 0.4.0.

[pronebird]

@oblique let me see if I can help you with windows-rs

[pronebird]

@oblique that was easy. See #10. Tests pass.