#language #day #hyperlane #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.

19 releases (7 stable)

new 3.3.0 Jan 13, 2025
2.0.0 Jan 11, 2025
1.0.0 Jan 10, 2025
0.8.0 Jan 10, 2025

#904 in Network programming

Download history 1684/week @ 2025-01-06

1,708 downloads per month
Used in 4 crates

MIT license

24KB
287 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();

test_async_recoverable_spawn_catch_finally

use recoverable_spawn::*;
let msg: &str = "test";
let handle: JoinHandle<()> = test_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