recoverable-spawn 3.9.19

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.
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use crate::*;

/// Executes a recoverable function within a panic-safe context.
///
/// # Arguments
///
/// - `F` - Function implementing RecoverableFunction.
///
/// # Returns
///
/// - `SyncSpawnResult` - The spawn operation result.
pub fn run_function<F: RecoverableFunction>(func: F) -> SyncSpawnResult {
    set_hook(Box::new(move |_| {}));
    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        func();
    }))
}

/// Executes an error-handling function within a panic-safe context.
///
/// # Arguments
///
/// - `E` - Function implementing ErrorHandlerFunction.
/// - `&str` - The error message.
///
/// # Returns
///
/// - `SyncSpawnResult` - The spawn operation result.
pub fn run_error_handle_function<E: ErrorHandlerFunction>(func: E, error: &str) -> SyncSpawnResult {
    set_hook(Box::new(move |_| {}));
    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        func(error);
    }))
}

/// Converts a panic-captured error value into a string.
///
/// # Arguments
///
/// - `&SpawnError` - The captured error value.
///
/// # Returns
///
/// - `String` - The error string representation.
pub fn spawn_error_to_string(err: &SpawnError) -> String {
    match err.downcast_ref::<&str>() {
        Some(str_slice) => str_slice.to_string(),
        None => match err.downcast_ref::<String>() {
            Some(string) => string.to_owned(),
            None => format!("{err:?}"),
        },
    }
}

/// Spawns a recoverable function.
///
/// # Arguments
///
/// - `F` - Function implementing RecoverableFunction.
///
/// # Returns
///
/// - `SyncSpawnResult` - The spawn operation result.
pub fn recoverable_spawn<F>(function: F) -> SyncSpawnResult
where
    F: RecoverableFunction,
{
    run_function(function)
}

/// Spawns a recoverable function with error handling.
///
/// # Arguments
///
/// - `F` - Function implementing RecoverableFunction.
/// - `E` - Function implementing ErrorHandlerFunction.
///
/// # Returns
///
/// - `SyncSpawnResult` - The spawn operation result.
pub fn recoverable_spawn_catch<F, E>(function: F, error_handle_function: E) -> SyncSpawnResult
where
    F: RecoverableFunction,
    E: ErrorHandlerFunction,
{
    let run_result: SyncSpawnResult = run_function(function);
    if let Err(err) = run_result.as_ref() {
        let err_string: String = spawn_error_to_string(err);
        let _: SyncSpawnResult = run_error_handle_function(error_handle_function, &err_string);
    }
    run_result
}

/// Spawns a recoverable function with error handling and finalization.
///
/// # Arguments
///
/// - `F` - Function implementing RecoverableFunction.
/// - `E` - Function implementing ErrorHandlerFunction.
/// - `L` - Function implementing RecoverableFunction.
///
/// # Returns
///
/// - `SyncSpawnResult` - The spawn operation result.
pub fn recoverable_spawn_catch_finally<F, E, L>(
    function: F,
    error_handle_function: E,
    finally: L,
) -> SyncSpawnResult
where
    F: RecoverableFunction,
    E: ErrorHandlerFunction,
    L: RecoverableFunction,
{
    let run_result: SyncSpawnResult = run_function(function);
    if let Err(err) = run_result.as_ref() {
        let err_string: String = spawn_error_to_string(err);
        let _: SyncSpawnResult = run_error_handle_function(error_handle_function, &err_string);
    }
    let _: SyncSpawnResult = run_function(finally);
    run_result
}