ctrlc2 4.0.0

Easy Ctrl-C handler version 2 for Rust projects
Documentation 
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

# CtrlC2


[![Version](https://img.shields.io/crates/v/ctrlc2.svg?style=flat)](https://crates.io/crates/ctrlc2)
[![Documentation](https://img.shields.io/badge/docs-release-brightgreen.svg?style=flat)](https://docs.rs/ctrlc2)
[![Download](https://img.shields.io/crates/d/ctrlc2.svg)](https://crates.io/crates/ctrlc2)
[![License](https://img.shields.io/crates/l/ctrlc2.svg?style=flat)](https://github.com/ssrlive/ctrlc2/blob/master/LICENSE-MIT)

> For [this reason](https://github.com/Detegr/rust-ctrlc/pull/110), I have decided to create a fork of [ctrlc](https://github.com/Detegr/rust-ctrlc) and maintain it.
> I will try to keep it up to date with the original repo. If you have any suggestions or want to contribute, please open an issue or a PR. Thanks!
> I will respond to issues and PRs as soon as possible.

A simple easy to use wrapper around Ctrl-C signal.

[Documentation](https://docs.rs/ctrlc2/)

## Example usage


In `cargo.toml`:

```toml
[dependencies]
ctrlc2 = "3.7"
```

then, in `main.rs`

```rust, no_run
{
    let handle = ctrlc2::set_handler(move || {
        println!(" ");
        println!("Ctrl-C received, ready to exiting...");
        true
    })
    .unwrap();
    println!("Waiting for Ctrl-C...");
    handle.join().unwrap();
    println!("Got it! Exiting...");
}
```

### Asynchronous support


This library now supports asynchronous operation. You can use the `async` feature, it very simple:

```rust, no_run
#[cfg(feature = "async")]

#[tokio::main(flavor = "current_thread")]

async fn main() {
    let ctrlc = ctrlc2::AsyncCtrlC::new(move || {
        println!("Ctrl-C received! Ready to exiting...");
        true
    })
    .expect("cannot create Ctrl+C handler");

    println!("Waiting for Ctrl-C...");
    ctrlc.await.unwrap();
    println!("Got it! Exiting...");
}

#[cfg(not(feature = "async"))]

fn main() {
    println!("This example requires the `async` feature to be enabled.");
}
```

#### Try the example yourself

`cargo build --examples && target/debug/examples/readme_example`

## Handling SIGTERM and SIGHUP

Add CtrlC to Cargo.toml using `termination` feature and CtrlC will handle SIGINT, SIGTERM and SIGHUP.

## License


Licensed under either of

* Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or [APACHE](http://www.apache.org/licenses/LICENSE-2.0))
* MIT license ([LICENSE-MIT](LICENSE-MIT) or [MIT](http://opensource.org/licenses/MIT))

at your option.

### Contribution


Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you shall be dual licensed as above, without any
additional terms or conditions.

## Similar crates


There are alternatives that give you more control over the different signals and/or add async support.

- [signal-hook](https://github.com/vorner/signal-hook)
- [tokio::signal](https://docs.rs/tokio/latest/tokio/signal/index.html)