refactor: Use an enum for input source names

Author: alixinne

src/api/flat.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use thiserror::Error;
 
 use crate::{
-    global::{Global, InputMessage, InputMessageData, InputSourceHandle},
+    global::{Global, InputMessage, InputMessageData, InputSourceHandle, InputSourceName},
     image::{RawImage, RawImageError},
     models::Color,
     utils::i32_to_duration,
@@ -103,7 +103,10 @@ pub async fn handle_request(
                 *source = Some(
                     global
                         .register_input_source(
-                            format!("FlatBuffers({}): {}", peer_addr, register.origin()),
+                            InputSourceName::FlatBuffers {
+                                peer_addr,
+                                origin: register.origin().to_owned(),
+                            },
                             Some(priority),
                         )
                         .await

src/global.rs

@@ -1,6 +1,8 @@
 use std::collections::HashMap;
+use std::net::SocketAddr;
 use std::sync::Arc;
 
+use parse_display::Display;
 use tokio::sync::broadcast;
 use tokio::sync::RwLock;
 
@@ -28,10 +30,25 @@ pub trait Message: Sized {
 #[derive(Clone)]
 pub struct Global(Arc<RwLock<GlobalData>>);
 
+#[derive(Display, Debug)]
+pub enum InputSourceName {
+    #[display("FlatBuffers({peer_addr}): {origin}")]
+    FlatBuffers {
+        peer_addr: SocketAddr,
+        origin: String,
+    },
+    #[display("JSON({peer_addr})")]
+    Json { peer_addr: SocketAddr },
+    #[display("Protobuf({peer_addr})")]
+    Protobuf { peer_addr: SocketAddr },
+    #[display("PriorityMuxer")]
+    PriorityMuxer,
+}
+
 impl Global {
     pub async fn register_input_source(
         &self,
-        name: String,
+        name: InputSourceName,
         priority: Option<i32>,
     ) -> Result<InputSourceHandle<InputMessage>, InputSourceError> {
         let priority = if let Some(priority) = priority {
@@ -53,7 +70,7 @@ impl Global {
 
     pub async fn register_muxed_source(
         &self,
-        name: String,
+        name: InputSourceName,
     ) -> Result<InputSourceHandle<MuxedMessage>, InputSourceError> {
         Ok(InputSourceHandle {
             input_source: self.0.write().await.register_muxed_source(name),
@@ -107,7 +124,7 @@ impl GlobalData {
 
     fn register_input_source(
         &mut self,
-        name: String,
+        name: InputSourceName,
         priority: Option<i32>,
     ) -> Arc<InputSource<InputMessage>> {
         let id = self.next_input_source_id;
@@ -133,7 +150,7 @@ impl GlobalData {
         }
     }
 
-    fn register_muxed_source(&mut self, name: String) -> Arc<InputSource<MuxedMessage>> {
+    fn register_muxed_source(&mut self, name: InputSourceName) -> Arc<InputSource<MuxedMessage>> {
         let id = self.next_muxed_source_id;
         self.next_muxed_source_id += 1;
 

src/global/input_source.rs

@@ -4,13 +4,13 @@ use parse_display::Display;
 use thiserror::Error;
 use tokio::sync::broadcast;
 
-use crate::global::{Global, Message};
+use super::{Global, InputSourceName, Message};
 
 #[derive(Display)]
 #[display("`{name}` (id = {id}, priority = {priority:?})")]
 pub struct InputSource<T: Message> {
     pub(super) id: usize,
-    pub(super) name: String,
+    pub(super) name: InputSourceName,
     pub(super) priority: Option<i32>,
     pub(super) tx: broadcast::Sender<T>,
 }

src/muxer.rs

@@ -6,7 +6,10 @@ use tokio::select;
 use tokio::sync::broadcast::Receiver;
 
 use crate::{
-    global::{Global, InputMessage, InputMessageData, InputSourceHandle, Message, MuxedMessage},
+    global::{
+        Global, InputMessage, InputMessageData, InputSourceHandle, InputSourceName, Message,
+        MuxedMessage,
+    },
     models::Color,
 };
 
@@ -28,7 +31,7 @@ impl PriorityMuxer {
         let mut this = Self {
             receiver: global.subscribe_input().await,
             source_handle: global
-                .register_muxed_source("PriorityMuxer".to_owned())
+                .register_muxed_source(InputSourceName::PriorityMuxer)
                 .await
                 .unwrap(),
             inputs: Default::default(),

src/servers/json.rs

@@ -9,7 +9,7 @@ use tokio_util::codec::Framed;
 
 use crate::{
     api::json::{self, JsonApiError},
-    global::Global,
+    global::{Global, InputSourceName},
 };
 
 /// JSON protocol codec definition
@@ -37,7 +37,7 @@ pub async fn handle_client(
 
     // unwrap: cannot fail because the priority is None
     let source = global
-        .register_input_source(format!("JSON({})", peer_addr), None)
+        .register_input_source(InputSourceName::Json { peer_addr }, None)
         .await
         .unwrap();
 

src/servers/proto.rs

@@ -9,7 +9,7 @@ use tokio::net::TcpStream;
 
 use crate::{
     api::proto::{self, message, ProtoApiError},
-    global::{Global, InputMessage, InputSourceHandle},
+    global::{Global, InputMessage, InputSourceHandle, InputSourceName},
 };
 
 #[derive(Debug, Error)]
@@ -86,7 +86,7 @@ pub async fn handle_client(
 
     // unwrap: cannot fail because the priority is None
     let source = global
-        .register_input_source(format!("Protobuf({})", peer_addr), None)
+        .register_input_source(InputSourceName::Protobuf { peer_addr }, None)
         .await
         .unwrap();