arty 0.5.0

Single-threaded, thread-aware application runtime.
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

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! Runtime owner destruction during a task unwind must not join or panic on that task's thread.

#![cfg(feature = "rt")]
#![cfg(test)]

mod panic_support;

mod support;

use std::cell::RefCell;
use std::sync::mpsc;

use panic_support::runtime;
use support::JoinHandleExt as _;
use testing_aids::TEST_TIMEOUT;
use thread_aware::Unaware;

testing_aids::init_tracing!();

struct Exited(mpsc::Sender<()>);

impl Drop for Exited {
    fn drop(&mut self) {
        let _ = self.0.send(());
    }
}

thread_local! {
    static EXIT: RefCell<Option<Exited>> = const { RefCell::new(None) };
}

struct Canary(mpsc::Sender<()>);

impl Drop for Canary {
    fn drop(&mut self) {
        self.0.send(()).unwrap();
    }
}

fn owner_unwind(blocking: bool) {
    let runtime = runtime();
    let (exited, retired) = mpsc::channel();
    let scheduler = runtime
        .scheduler()
        .block_on(async move |cx| {
            EXIT.with_borrow_mut(|exit| *exit = Some(Exited(exited)));
            cx.scheduler().clone()
        })
        .unwrap();
    let (started, ready) = mpsc::channel();
    let (dropped, cancelled) = mpsc::channel();
    let canary = runtime
        .scheduler()
        .spawn_anywhere(Unaware((started, dropped)), |_, Unaware((started, dropped))| async move {
            let guard = Canary(dropped);
            started.send(()).unwrap();
            std::future::pending::<()>().await;
            drop(guard);
        });
    ready.recv_timeout(TEST_TIMEOUT).unwrap();
    let failed: arty::task::JoinHandle<()> = if blocking {
        scheduler.spawn_blocking(move || {
            let _owner = runtime;
            panic!("blocking callback owning runtime");
        })
    } else {
        scheduler.spawn(async move |_| {
            let _owner = runtime;
            panic!("async task owning runtime");
        })
    };
    assert!(failed.join().unwrap_err().is_panic());
    cancelled.recv_timeout(TEST_TIMEOUT).unwrap();
    assert!(canary.join().unwrap_err().is_shutdown());
    assert!(scheduler.spawn(async |_| 42).join().unwrap_err().is_shutdown());
    retired.recv_timeout(TEST_TIMEOUT).unwrap();
}

#[test]
fn async_owner_drop_during_user_panic_requests_independent_shutdown() {
    owner_unwind(false);
}

#[test]
fn blocking_owner_drop_during_user_panic_requests_independent_shutdown() {
    owner_unwind(true);
}