s2n-quic-dc 0.45.0

Internal crate used by s2n-quic
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

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

use crate::stream::{recv, send};
use core::{mem::MaybeUninit, ops};
use std::sync::Arc;

impl super::Handle for tokio::runtime::Handle {
    #[inline]
    fn spawn_recv_shutdown(&self, shutdown: recv::application::Shutdown) {
        self.spawn(async move {
            // Note: Must be created inside spawn() since ambient runtime is otherwise not
            // guaranteed and will cause a panic on the timeout future construction.
            // make sure the task doesn't hang around indefinitely
            tokio::time::timeout(core::time::Duration::from_secs(1), shutdown).await
        });
    }

    #[inline]
    fn spawn_send_shutdown(&self, shutdown: send::application::Shutdown) {
        self.spawn(async move {
            // Note: Must be created inside spawn() since ambient runtime is otherwise not
            // guaranteed and will cause a panic on the timeout future construction.
            // make sure the task doesn't hang around indefinitely
            tokio::time::timeout(core::time::Duration::from_secs(1), shutdown).await
        });
    }
}

#[derive(Clone)]
pub struct Shared(Arc<SharedInner>);

impl Shared {
    #[inline]
    pub fn handle(&self) -> super::ArcHandle {
        self.0.clone()
    }
}

impl ops::Deref for Shared {
    type Target = tokio::runtime::Handle;

    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl From<tokio::runtime::Runtime> for Shared {
    fn from(rt: tokio::runtime::Runtime) -> Self {
        Self(Arc::new(SharedInner(MaybeUninit::new(rt))))
    }
}

struct SharedInner(MaybeUninit<tokio::runtime::Runtime>);

impl ops::Deref for SharedInner {
    type Target = tokio::runtime::Handle;

    #[inline]
    fn deref(&self) -> &Self::Target {
        unsafe { (self.0).assume_init_ref().handle() }
    }
}

impl super::Handle for SharedInner {
    #[inline]
    fn spawn_recv_shutdown(&self, shutdown: recv::application::Shutdown) {
        (**self).spawn_recv_shutdown(shutdown)
    }

    #[inline]
    fn spawn_send_shutdown(&self, shutdown: send::application::Shutdown) {
        (**self).spawn_send_shutdown(shutdown)
    }
}

impl Drop for SharedInner {
    fn drop(&mut self) {
        // drop the runtimes in a separate thread to avoid tokio complaining
        let rt = unsafe { self.0.assume_init_read() };
        std::thread::spawn(move || {
            // give enough time for all of the streams to shut down
            rt.shutdown_timeout(core::time::Duration::from_secs(10));
        });
    }
}