twilight-gateway 0.9.0

Discord Gateway implementation for the Twilight ecosystem.
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

use super::super::ShardStream;
use futures_util::{
    future::{self, Either},
    sink::SinkExt,
    stream::StreamExt,
};
use std::time::Duration;
use tokio::{
    sync::mpsc::{self, UnboundedReceiver, UnboundedSender},
    time::sleep,
};
use tokio_tungstenite::tungstenite::Message;

pub struct SocketForwarder {
    rx: UnboundedReceiver<Message>,
    pub stream: ShardStream,
    tx: UnboundedSender<Message>,
}

impl SocketForwarder {
    const TIMEOUT: Duration = Duration::from_secs(90);

    pub fn new(
        stream: ShardStream,
    ) -> (Self, UnboundedReceiver<Message>, UnboundedSender<Message>) {
        let (to_user, from_forwarder) = mpsc::unbounded_channel();
        let (to_forwarder, from_user) = mpsc::unbounded_channel();

        (
            Self {
                rx: from_user,
                stream,
                tx: to_user,
            },
            from_forwarder,
            to_forwarder,
        )
    }

    pub async fn run(mut self) {
        #[cfg(feature = "tracing")]
        tracing::debug!("starting driving loop");

        loop {
            tokio::pin! {
                let timeout = sleep(Self::TIMEOUT);
                let rx = self.rx.recv();
                let tx = self.stream.next();
            }

            let select_message = future::select(rx, tx);

            match future::select(select_message, timeout).await {
                // `rx` future finished first.
                Either::Left((Either::Left((maybe_msg, _)), _)) => {
                    if let Some(msg) = maybe_msg {
                        #[cfg(feature = "tracing")]
                        tracing::trace!("sending message: {}", msg);

                        if let Err(_source) = self.stream.send(msg).await {
                            #[cfg(feature = "tracing")]
                            tracing::warn!("sending failed: {}", _source);

                            break;
                        }
                    } else {
                        #[cfg(feature = "tracing")]
                        tracing::debug!("rx stream ended, closing socket");

                        let _res = self.stream.close(None).await;

                        break;
                    }
                }
                // `tx` future finished first.
                Either::Left((Either::Right((try_msg, _)), _)) => match try_msg {
                    Some(Ok(msg)) => {
                        if self.tx.send(msg).is_err() {
                            break;
                        }
                    }
                    Some(Err(_source)) => {
                        #[cfg(feature = "tracing")]
                        tracing::warn!("socket errored: {}", _source);

                        break;
                    }
                    None => {
                        #[cfg(feature = "tracing")]
                        tracing::debug!("socket ended");

                        break;
                    }
                },
                // Timeout future finished first.
                Either::Right(_) => {
                    #[cfg(feature = "tracing")]
                    tracing::warn!("socket timed out");

                    break;
                }
            }
        }

        #[cfg(feature = "tracing")]
        tracing::debug!("Leaving loop");
    }
}