axum-cometd 0.2.0

Framework for CometD server creation
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
123
124
125
126
127
128
129
130
131
132
133
134
135

use crate::LongPoolingServiceContext;
use ahash::AHashMap;
use std::sync::Arc;
use tokio::sync::RwLock;

const DEFAULT_TIMEOUT_MS: u64 = 20_000;
const DEFAULT_INTERVAL_MS: u64 = 0;
const DEFAULT_MAX_INTERVAL_MS: u64 = 60_000;
const DEFAULT_CHANNEL_CAPACITY: usize = 1_000_000;

/// A builder to construct `LongPoolingServiceContext`.
#[derive(Debug, Default)]
pub struct LongPoolingServiceContextBuilder {
    subscriptions_capacity: usize,
    client_ids_capacity: usize,
    consts: LongPoolingServiceContextConsts,
}

#[derive(Debug)]
pub(crate) struct LongPoolingServiceContextConsts {
    pub(crate) timeout_ms: u64,
    pub(crate) interval_ms: u64,
    pub(crate) max_interval_ms: u64,
    pub(crate) client_channel_capacity: usize,
    pub(crate) subscription_channel_capacity: usize,
}

impl Default for LongPoolingServiceContextConsts {
    #[inline(always)]
    fn default() -> Self {
        Self {
            timeout_ms: DEFAULT_TIMEOUT_MS,
            interval_ms: DEFAULT_INTERVAL_MS,
            max_interval_ms: DEFAULT_MAX_INTERVAL_MS,
            client_channel_capacity: DEFAULT_CHANNEL_CAPACITY,
            subscription_channel_capacity: DEFAULT_CHANNEL_CAPACITY,
        }
    }
}

impl LongPoolingServiceContextBuilder {
    /// Construct a new `LongPoolingServiceContextBuilder`.
    #[inline(always)]
    pub fn new() -> Self {
        Self::default()
    }

    /// Return a `LongPoolingServiceContextBuilder`.
    ///
    /// # Example
    /// ```rust
    /// use axum_cometd::LongPoolingServiceContextBuilder;
    ///
    /// let context = LongPoolingServiceContextBuilder::new().build();
    /// # let app = axum_cometd::RouterBuilder::new().build::<()>(&context);
    /// ```
    #[inline(always)]
    pub fn build<Msg>(self) -> Arc<LongPoolingServiceContext<Msg>> {
        let Self {
            subscriptions_capacity,
            client_ids_capacity,
            consts,
        } = self;

        Arc::new(LongPoolingServiceContext {
            consts,
            client_ids_by_subscriptions: RwLock::new(AHashMap::with_capacity(
                subscriptions_capacity,
            )),
            subscription_channels: RwLock::new(AHashMap::with_capacity(subscriptions_capacity)),
            client_id_channels: Arc::new(RwLock::new(AHashMap::with_capacity(client_ids_capacity))),
        })
    }

    /// Set message wait timeout in milliseconds.
    #[inline(always)]
    pub fn timeout_ms(self, timeout_ms: u64) -> Self {
        Self {
            consts: LongPoolingServiceContextConsts {
                timeout_ms,
                ..self.consts
            },
            ..self
        }
    }

    /// Set timeout in milliseconds, that the client must wait between two connects.
    #[inline(always)]
    pub fn interval_ms(self, _interval_ms: u64) -> Self {
        unimplemented!()
        /*Self {
            consts: LongPoolingServiceContextConsts {
                interval_ms,
                ..self.consts
            },
            ..self
        }*/
    }

    /// Set timeout in milliseconds, which server wait between erase clientId.
    #[inline(always)]
    pub fn max_interval_ms(self, max_interval_ms: u64) -> Self {
        Self {
            consts: LongPoolingServiceContextConsts {
                max_interval_ms,
                ..self.consts
            },
            ..self
        }
    }

    /// Set internal-channel capacity for clientId channel.
    #[inline(always)]
    pub fn client_channel_capacity(self, client_channel_capacity: usize) -> Self {
        Self {
            consts: LongPoolingServiceContextConsts {
                client_channel_capacity,
                ..self.consts
            },
            ..self
        }
    }

    /// Set internal-channel capacity for subscription channel.
    #[inline(always)]
    pub fn subscription_channel_capacity(self, subscription_channel_capacity: usize) -> Self {
        Self {
            consts: LongPoolingServiceContextConsts {
                subscription_channel_capacity,
                ..self.consts
            },
            ..self
        }
    }
}