Events: Break out and non-exhaust context body structs (#54)

This PR makes many of the types under `EventContext` separate `#[non_exhaustive]` structs. This makes it more feasible to add further information to connection and packet events as required in future. On this note, driver (re)connection events now include the SSRC supplied by Discord and the domain name which was connected to.

In addition, this fixes global timed events to return a list of all live tracks, and extensively details/documents events at a high level.

This was tested using `cargo make ready`.

src/driver/connection/mod.rs

@@ -36,6 +36,7 @@ use ws::create_native_tls_client;
 
 pub(crate) struct Connection {
     pub(crate) info: ConnectionInfo,
+    pub(crate) ssrc: u32,
     pub(crate) ws: Sender<WsMessage>,
 }
 
@@ -219,6 +220,7 @@ impl Connection {
 
         Ok(Connection {
             info,
+            ssrc,
             ws: ws_msg_tx,
         })
     }

src/driver/tasks/mod.rs

@@ -10,7 +10,10 @@ pub(crate) mod udp_tx;
 pub(crate) mod ws;
 
 use super::connection::{error::Error as ConnectionError, Connection};
-use crate::{events::CoreContext, Config};
+use crate::{
+    events::{internal_data::InternalConnect, CoreContext},
+    Config,
+};
 use flume::{Receiver, RecvError, Sender};
 use message::*;
 #[cfg(not(feature = "tokio-02-marker"))]
@@ -78,9 +81,12 @@ async fn runner(mut config: Config, rx: Receiver<CoreMessage>, tx: Sender<CoreMe
                         // Other side may not be listening: this is fine.
                         let _ = tx.send(Ok(()));
 
-                        let _ = interconnect
-                            .events
-                            .send(EventMessage::FireCoreEvent(CoreContext::DriverConnect));
+                        let _ = interconnect.events.send(EventMessage::FireCoreEvent(
+                            CoreContext::DriverConnect(InternalConnect {
+                                server: connection.info.endpoint.clone(),
+                                ssrc: connection.ssrc,
+                            }),
+                        ));
 
                         Some(connection)
                     },
@@ -164,10 +170,13 @@ async fn runner(mut config: Config, rx: Receiver<CoreMessage>, tx: Sender<CoreMe
                             .ok();
                     }
 
-                    if connection.is_some() {
-                        let _ = interconnect
-                            .events
-                            .send(EventMessage::FireCoreEvent(CoreContext::DriverReconnect));
+                    if let Some(ref connection) = &connection {
+                        let _ = interconnect.events.send(EventMessage::FireCoreEvent(
+                            CoreContext::DriverReconnect(InternalConnect {
+                                server: connection.info.endpoint.clone(),
+                                ssrc: connection.ssrc,
+                            }),
+                        ));
                     }
                 }
             },
@@ -186,10 +195,13 @@ async fn runner(mut config: Config, rx: Receiver<CoreMessage>, tx: Sender<CoreMe
                         })
                         .ok();
 
-                    if connection.is_some() {
-                        let _ = interconnect
-                            .events
-                            .send(EventMessage::FireCoreEvent(CoreContext::DriverReconnect));
+                    if let Some(ref connection) = &connection {
+                        let _ = interconnect.events.send(EventMessage::FireCoreEvent(
+                            CoreContext::DriverReconnect(InternalConnect {
+                                server: connection.info.endpoint.clone(),
+                                ssrc: connection.ssrc,
+                            }),
+                        ));
                     }
                 },
             Ok(CoreMessage::RebuildInterconnect) => {

src/driver/tasks/udp_rx.rs

@@ -3,7 +3,11 @@ use super::{
     message::*,
     Config,
 };
-use crate::{constants::*, driver::DecodeMode, events::CoreContext};
+use crate::{
+    constants::*,
+    driver::DecodeMode,
+    events::{internal_data::*, CoreContext},
+};
 use audiopus::{
     coder::Decoder as OpusDecoder,
     error::{Error as OpusError, ErrorCode},
@@ -322,30 +326,30 @@ impl UdpRx {
                     match delta {
                         SpeakingDelta::Start => {
                             let _ = interconnect.events.send(EventMessage::FireCoreEvent(
-                                CoreContext::SpeakingUpdate {
+                                CoreContext::SpeakingUpdate(InternalSpeakingUpdate {
                                     ssrc: rtp.get_ssrc(),
                                     speaking: true,
-                                },
+                                }),
                             ));
                         },
                         SpeakingDelta::Stop => {
                             let _ = interconnect.events.send(EventMessage::FireCoreEvent(
-                                CoreContext::SpeakingUpdate {
+                                CoreContext::SpeakingUpdate(InternalSpeakingUpdate {
                                     ssrc: rtp.get_ssrc(),
                                     speaking: false,
-                                },
+                                }),
                             ));
                         },
                         _ => {},
                     }
 
                     let _ = interconnect.events.send(EventMessage::FireCoreEvent(
-                        CoreContext::VoicePacket {
+                        CoreContext::VoicePacket(InternalVoicePacket {
                             audio,
                             packet: rtp.from_packet(),
                             payload_offset: rtp_body_start,
                             payload_end_pad: rtp_body_tail,
-                        },
+                        }),
                     ));
                 } else {
                     warn!("RTP decoding/processing failed.");
@@ -371,13 +375,16 @@ impl UdpRx {
                     )
                 });
 
-                let _ = interconnect.events.send(EventMessage::FireCoreEvent(
-                    CoreContext::RtcpPacket {
-                        packet: rtcp.from_packet(),
-                        payload_offset: start,
-                        payload_end_pad: tail,
-                    },
-                ));
+                let _ =
+                    interconnect
+                        .events
+                        .send(EventMessage::FireCoreEvent(CoreContext::RtcpPacket(
+                            InternalRtcpPacket {
+                                packet: rtcp.from_packet(),
+                                payload_offset: start,
+                                payload_end_pad: tail,
+                            },
+                        )));
             },
             DemuxedMut::FailedParse(t) => {
                 warn!("Failed to parse message of type {:?}.", t);