hwire 0.2.5

An HTTP library written in Rust
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

use std::{
    sync::{
        atomic::{AtomicBool, AtomicUsize, Ordering},
        Arc, OnceLock,
    },
    task::Context,
};

use futures_util::task::AtomicWaker;
use http::{Request, Response};
use tokio_util::sync::CancellationToken;

use crate::{body::Incoming, Error};

pub(crate) type Callback<B> = crate::dispatch::Callback<Request<B>, Response<Incoming>>;

pub(crate) struct Shared {
    #[cfg(feature = "http3-datagram")]
    pub(crate) datagrams: Option<Arc<super::datagram::Registry>>,
    pub(crate) peer_extended_connect: OnceLock<bool>,
    pub(crate) settings_ready: CancellationToken,
    pub(crate) draining: AtomicBool,
    pub(crate) active: AtomicUsize,
    pub(crate) waker: AtomicWaker,
    pub(crate) active_waker: AtomicWaker,
    pub(crate) closed: CancellationToken,
    pub(crate) error: OnceLock<Arc<Error>>,
}

pub(crate) struct Active(pub(crate) Arc<Shared>);

// ===== impl Shared =====

impl Shared {
    pub(crate) fn new(
        #[cfg(feature = "http3-datagram")] datagrams: Option<Arc<super::datagram::Registry>>,
    ) -> Arc<Self> {
        Arc::new(Self {
            #[cfg(feature = "http3-datagram")]
            datagrams,
            peer_extended_connect: OnceLock::new(),
            settings_ready: CancellationToken::new(),
            draining: AtomicBool::new(false),
            active: AtomicUsize::new(0),
            waker: AtomicWaker::new(),
            active_waker: AtomicWaker::new(),
            closed: CancellationToken::new(),
            error: OnceLock::new(),
        })
    }

    pub(crate) fn drain(&self) {
        if !self.draining.swap(true, Ordering::AcqRel) {
            self.waker.wake();
        }
    }

    pub(crate) fn terminate(&self, error: Error) {
        self.error.get_or_init(|| Arc::new(error));
        self.drain();
        self.closed.cancel();
        #[cfg(feature = "http3-datagram")]
        if let Some(datagrams) = &self.datagrams {
            datagrams.close();
        }
    }

    pub(crate) fn error(&self) -> Error {
        self.error
            .get()
            .map_or_else(Error::new_canceled, |e| Error::from_shared(e.clone()))
    }

    pub(crate) fn register(&self, cx: &Context<'_>) {
        self.waker.register(cx.waker());
    }
}

// ===== impl Active =====

impl Drop for Active {
    fn drop(&mut self) {
        self.0.active.fetch_sub(1, Ordering::AcqRel);
        self.0.active_waker.wake();
    }
}