Allow FnMut handler functions and placate clippy

[bossmc]

Started as "the handler function can be a FnMut without any other changes"... went down a bit of a rabbit hole while I was there:

• Fixed up various clippy warnings
• Removed the nightly feature since static_mutex/static_condvar has disappeared in nightly (you might consider keeping the feature name as a no-op so this isn't a breaking change?)
• Replaced some deprecated code (AtomicUint::compare_and_swap)

I also considered but managed to stop myself from:

• Running cargo fmt - but it broken up a lot of single lines into three lines in an annoying way, could still be worth doing
• Adding clippy/fmt to the travis-ci script - couldn't add fmt due to previous bullet and didn't add clippy because it's annoying to add (do you enable -Dwarnings? do you allow_failure? what if clippy adds a new lint?)

[swizard0]

Hi! Is this "println!" here for a reason or it is just kind of debugging forgotten?

[bossmc]

It's there for a reason, but not a great one 😄 I wanted to prove the handler could be FnMut by testing with one that mutates captured variables, so I added the signal_count variable - then rust complained that it was unreferenced (since the code only increments it).

I added the printf to "use" the variable (and you can see the output with cargo test -- --nocapture) - I considered sending the current value out of the closure on a new channel and asserting the current count on the outside (as the test already does for the signals), but that's not really testing anything meaningful.

[swizard0]

Ah, okay, I got it :)

I doubt that the handler could really be FnMut, I have a strong feeling that we cannot directly mutate anything from another (detached) thread via &mut reference.

For example consider the main thread has exited before the one in set_handler, then any access from it will trigger segmentation fault.

[bossmc]

FnMut allows mutation of captured variables, which is independent to accessing &mut references. The use case I wanted was something like:

async fn main() {
  let (rx, tx) = tokio::sync::oneshot();
  let mut tx = Some(tx);
  set_handler(&signals, move |_| {
    if let Some(tx) = tx.take() {        // `take` needs `FnMut`
      tx.send("shutdown now please");
    }
  })

  tokio::spawn(...); // etc.

  rx.await;

  info!("Shutting down now");
}

As the handler is 'static it can't capture references (mutable or otherwise) which prevents the segfault you were thinking about.

[swizard0]

okay that sounds perfectly reasonable!