#hyperlane #language #day #format #web-programming #networking #time

recoverable-spawn

A thread that supports automatic recovery from panics, allowing threads to restart after a panic. Useful for resilient and fault-tolerant concurrency in network and web programming.

25 releases (13 stable)

3.4.1 Feb 9, 2025
2.0.0 Jan 11, 2025
1.0.0 Jan 10, 2025
0.8.0 Jan 10, 2025

#1135 in Network programming

Download history 1111/week @ 2025-01-07 807/week @ 2025-01-14 219/week @ 2025-01-21 18/week @ 2025-01-28 278/week @ 2025-02-04 248/week @ 2025-02-11

977 downloads per month
Used in 5 crates (4 directly)

MIT license

33KB
389 lines

recoverable-spawn

Official Documentation

Api Docs

A thread that supports automatic recovery from panics, allowing threads to restart after a panic. Useful for resilient and fault-tolerant concurrency in network and web programming.

Installation

To use this crate, you can run cmd:

cargo add recoverable-spawn

Use

recoverable_spawn

use recoverable_spawn::*;
let msg: &str = "test";
let handle: JoinHandle<()> = recoverable_spawn(move || {
    panic!("{}", msg);
});
let _ = handle.join();
let handle: JoinHandle<()> = recoverable_spawn_with_error_handle(
    move || {
        panic!("{}", msg);
    },
    |err| {
        println!("handle error => {}", err);
    },
);
let _ = handle.join();

recoverable_spawn_with_error_handle

use recoverable_spawn::*;
let msg: &str = "test";
let handle: JoinHandle<()> = recoverable_spawn_with_error_handle(
    move || {
        panic!("{}", msg);
    },
    |err| {
        println!("handle error => {}", err);
    },
);
let _ = handle.join();

async_recoverable_spawn

use recoverable_spawn::*;
let msg: &str = "test";
let handle: JoinHandle<()> = async_recoverable_spawn(move || async move {
    panic!("{}", msg);
});
let _ = handle.join();

async_recoverable_spawn_catch

use recoverable_spawn::*;
let msg: &str = "test";
let handle: JoinHandle<()> = async_recoverable_spawn_catch(
    move || async move {
        panic!("{}", msg);
    },
    move |err| async move {
        println!("handle error => {}", err);
    },
);
let _ = handle.join();

async_recoverable_spawn_catch_finally

use recoverable_spawn::*;
let msg: &str = "test";
let handle: JoinHandle<()> = async_recoverable_spawn_catch_finally(
    move || async move {
        panic!("{}", msg);
    },
    move |err| async move {
        println!("handle error => {}", err);
        panic!("{}", err);
    },
    move || async move {
        println!("finally");
    },
);
let _ = handle.join();

License

This project is licensed under the MIT License. See the LICENSE file for details.

Contributing

Contributions are welcome! Please open an issue or submit a pull request.

Contact

For any inquiries, please reach out to the author at ltpp-universe root@ltpp.vip.

Dependencies

~2.4–8MB
~58K SLoC