Use enum_dispatch instead of dyn traits

Author: bcaldwell

Cargo.lock

@@ -14,6 +14,7 @@
             pkgs.rustc
             # pkgs.rustup
             pkgs.rustfmt
+            pkgs.rust-analyzer
             pkgs.cargo-edit
             pkgs.go-task
             # needed for linker to work with tokio

flake.nix

@@ -19,3 +19,4 @@ shellexpand = "2.1.0"
 reqwest = { version = "0.11", default-features = false, features = [ "json", "rustls-tls" ] }
 tracing = "0.1.35"
 url = { version = "2.2.2", features = ["serde"] }
+enum_dispatch = "0.3.8"

integrations/Cargo.toml

@@ -43,13 +43,13 @@ pub struct IntegrationConfig {
 
 #[async_trait]
 impl integration::IntegrationConfig for IntegrationConfig {
-    async fn to_integration(&self, name: Option<String>) -> integration::IntegrationResult {
+    async fn into_integration(&self, name: Option<String>) -> integration::IntegrationResult {
         let i = Integration::new(
             name.unwrap_or("airplay".to_string()),
             &self.api_endpoint,
             &self.devices,
         )?;
-        return Ok(Box::new(i));
+        return Ok(i.into());
     }
 }
 

integrations/src/integrations/airplay.rs

@@ -17,7 +17,7 @@ pub struct IntegrationConfig {
 
 #[async_trait]
 impl integration::IntegrationConfig for IntegrationConfig {
-    async fn to_integration(&self, name: Option<String>) -> integration::IntegrationResult {
+    async fn into_integration(&self, name: Option<String>) -> integration::IntegrationResult {
         let username = shellexpand::env(&self.username)?.to_string();
         let password = shellexpand::env(&self.password)?.to_string();
 
@@ -28,7 +28,7 @@ impl integration::IntegrationConfig for IntegrationConfig {
             &password,
         )
         .await?;
-        return Ok(Box::new(i));
+        return Ok(i.into());
     }
 }
 

integrations/src/integrations/homebridge.rs

@@ -8,10 +8,9 @@ pub struct IntegrationConfig {}
 
 #[async_trait]
 impl integration::IntegrationConfig for IntegrationConfig {
-    async fn to_integration(&self, name: Option<String>) -> integration::IntegrationResult {
-        return Ok(Box::new(Integration::new(
-            name.unwrap_or("http".to_string()),
-        )));
+    async fn into_integration(&self, name: Option<String>) -> integration::IntegrationResult {
+        let integration = Integration::new(name.unwrap_or("http".to_string()));
+        return Ok(integration.into());
     }
 }
 

integrations/src/integrations/http.rs

@@ -15,10 +15,10 @@ pub struct IntegrationConfig {
 
 #[async_trait]
 impl integration::IntegrationConfig for IntegrationConfig {
-    async fn to_integration(&self, name: Option<String>) -> integration::IntegrationResult {
+    async fn into_integration(&self, name: Option<String>) -> integration::IntegrationResult {
         let auth = shellexpand::env(&self.auth)?.to_string();
         let i = Integration::new(name.unwrap_or("hue".to_string()).as_ref(), &auth).await?;
-        return Ok(Box::new(i));
+        return Ok(i.into());
     }
 }
 

integrations/src/integrations/hue.rs

@@ -1,19 +1,50 @@
+use crate::integrations::IntegrationEnum;
+
 use anyhow::Result;
 use async_trait::async_trait;
+use enum_dispatch::enum_dispatch;
 
-pub type IntegrationResult = Result<Box<dyn Integration + Send + Sync>>;
+pub type IntegrationResult = Result<IntegrationEnum>;
 
+// IntegrationConfig is implemented by the integration, to convert some configuration (on the struct) to an integration in the ingegration enum
 #[async_trait]
 pub trait IntegrationConfig {
-    async fn to_integration(&self, name: Option<String>) -> IntegrationResult;
+    async fn into_integration(&self, name: Option<String>) -> IntegrationResult;
 }
 
+// Intregration is the core logic of an integration
 #[async_trait]
+#[enum_dispatch]
 pub trait Integration {
     fn name(&self) -> &str;
-    // fn actions(&self) -> Vec<&str>;
     async fn execute_action(&self, action: String, options: serde_json::value::Value)
         -> Result<()>;
+}
+
+// IntoIntegration is a helper trait for converting an integration into an integration result
+// can't use the normal into trait since converting to an integration can fail, so this returns a result
+// I think this can be try_into trait but not sure how to convert it
+#[async_trait]
+#[enum_dispatch]
+pub trait IntoIntegration {
+    async fn into_integration(&self) -> IntegrationResult;
+}
+
+// IntegrationConfiguration implements IntoIntegration, by calling IntegrationConfig, with the embeded name
+// This struct is used for the configuration of integrations, and is what is exposed to the end user
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+pub struct IntegrationConfiguration<T: IntegrationConfig> {
+    name: Option<String>,
+    #[serde(flatten)]
+    options: T,
+}
 
-    // fn resync(&self);
+#[async_trait]
+impl<T> IntoIntegration for IntegrationConfiguration<T>
+where
+    T: IntegrationConfig + Sync + Send,
+{
+    async fn into_integration(&self) -> IntegrationResult {
+        return self.options.into_integration(self.name.clone()).await;
+    }
 }

integrations/src/integrations/integration.rs

@@ -0,0 +1,37 @@
+use crate::integrations::{airplay, homebridge, http, hue};
+use crate::integrations::{
+    Integration, IntegrationConfiguration, IntegrationResult, IntoIntegration,
+};
+
+use anyhow::Result;
+use enum_dispatch::enum_dispatch;
+
+#[enum_dispatch(Integration)]
+pub enum IntegrationEnum {
+    Hue(hue::Integration),
+    Homebridge(homebridge::Integration),
+    Http(http::Integration),
+    Airplay(airplay::Integration),
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "type")]
+#[serde(rename_all = "snake_case")]
+#[enum_dispatch(IntoIntegration)]
+pub enum IntegrationsConfigurationEnum {
+    Hue(IntegrationConfiguration<hue::IntegrationConfig>),
+    Homebridge(IntegrationConfiguration<homebridge::IntegrationConfig>),
+    Airplay(IntegrationConfiguration<airplay::IntegrationConfig>),
+    Http(IntegrationConfiguration<http::IntegrationConfig>),
+}
+
+impl std::fmt::Display for IntegrationsConfigurationEnum {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            IntegrationsConfigurationEnum::Hue(_) => write!(f, "hue"),
+            IntegrationsConfigurationEnum::Homebridge(_) => write!(f, "homebridge"),
+            IntegrationsConfigurationEnum::Airplay(_) => write!(f, "airplay"),
+            IntegrationsConfigurationEnum::Http(_) => write!(f, "http"),
+        }
+    }
+}

integrations/src/integrations/integration_enum.rs

@@ -3,6 +3,8 @@ pub mod homebridge;
 pub mod http;
 pub mod hue;
 mod integration;
+mod integration_enum;
 pub(crate) mod utils;
 
 pub use integration::*;
+pub use integration_enum::*;

integrations/src/integrations/mod.rs

@@ -25,3 +25,4 @@ reqwest = { version = "0.11", default-features = false, features = [ "json", "ru
 shellexpand = "2.1.0"
 tracing = "0.1.35"
 tracing-subscriber = "0.3.14"
+enum_dispatch = "0.3.8"

server/Cargo.toml

@@ -1,5 +1,5 @@
 use anyhow::{anyhow, Result};
-use integrations::Integration;
+use integrations::{Integration, IntegrationEnum, IntegrationsConfigurationEnum, IntoIntegration};
 use sdc_core::types::{Actions, ExecuteActionReq, Profiles};
 use std::collections::HashMap;
 use std::env;
@@ -15,55 +15,10 @@ mod ws_api;
 
 const ACTION_SPLIT_CHARS: [char; 2] = [':', ':'];
 
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
-struct IntegrationConfiguration<T: integrations::IntegrationConfig> {
-    name: Option<String>,
-    #[serde(flatten)]
-    options: T,
-}
-
-impl<T: integrations::IntegrationConfig> IntegrationConfiguration<T> {
-    async fn as_integration(&self) -> integrations::IntegrationResult {
-        return self.options.to_integration(self.name.clone()).await;
-    }
-}
-
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
-#[serde(tag = "type")]
-#[serde(rename_all = "snake_case")]
-enum IntegrationsConfiguration {
-    Hue(IntegrationConfiguration<integrations::hue::IntegrationConfig>),
-    Homebridge(IntegrationConfiguration<integrations::integrations::homebridge::IntegrationConfig>),
-    Airplay(IntegrationConfiguration<integrations::airplay::IntegrationConfig>),
-    Http(IntegrationConfiguration<integrations::http::IntegrationConfig>),
-}
-
-impl IntegrationsConfiguration {
-    async fn as_integration(&self) -> integrations::IntegrationResult {
-        match self {
-            IntegrationsConfiguration::Hue(c) => c.as_integration().await,
-            IntegrationsConfiguration::Homebridge(c) => c.as_integration().await,
-            IntegrationsConfiguration::Airplay(c) => c.as_integration().await,
-            IntegrationsConfiguration::Http(c) => c.as_integration().await,
-        }
-    }
-}
-
-impl std::fmt::Display for IntegrationsConfiguration {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match self {
-            IntegrationsConfiguration::Hue(_) => write!(f, "hue"),
-            IntegrationsConfiguration::Homebridge(_) => write!(f, "homebridge"),
-            IntegrationsConfiguration::Airplay(_) => write!(f, "airplay"),
-            IntegrationsConfiguration::Http(_) => write!(f, "http"),
-        }
-    }
-}
-
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub struct Config {
-    integrations: Vec<IntegrationsConfiguration>,
+    integrations: Vec<IntegrationsConfigurationEnum>,
     profiles: Profiles,
 }
 
@@ -132,7 +87,7 @@ async fn populat_image_cache(config_ref: Arc<Config>, image_cache: ws_api::Image
 }
 
 struct IntegrationManager {
-    integrations: HashMap<String, Box<dyn Integration + Send + Sync>>,
+    integrations: HashMap<String, IntegrationEnum>,
     rx: Receiver<ExecuteActionReq>,
     ws_clients: ws_api::Clients,
 }
@@ -155,7 +110,7 @@ impl IntegrationManager {
                 integration = integration.to_string(),
                 "setting up integration"
             );
-            let i = integration.as_integration().await.map_err(|err| {
+            let i = integration.into_integration().await.map_err(|err| {
                 error!(?integration, error = ?err, "failed to create integration");
                 anyhow!(
                     "failed to create integration {:?} with {:?}",
@@ -175,7 +130,7 @@ impl IntegrationManager {
         return Ok((manager, tx));
     }
 
-    fn add_integration(&mut self, integration: Box<dyn Integration + Send + Sync>) {
+    fn add_integration(&mut self, integration: IntegrationEnum) {
         self.integrations
             .insert(integration.name().to_string(), integration);
     }
@@ -238,7 +193,6 @@ impl IntegrationManager {
             match integration_option {
                 Some(integration) => {
                     integration
-                        .as_ref()
                         .execute_action(action_name.to_string(), options)
                         .await?;
                 }

server/src/main.rs

@@ -6,7 +6,6 @@ use futures_util::StreamExt;
 use image::{self, Pixel};
 use sdc_core::types::{ExecuteActionReq, ProfileButtonPressed, SetButtonUI, WsActions};
 use std::collections::HashMap;
-use std::ops::ControlFlow;
 use std::sync::Arc;
 use tokio::sync::mpsc;
 use tokio::sync::mpsc::UnboundedSender;
@@ -156,7 +155,7 @@ async fn handle_msg(
         Some(id),
     )
     .await
-    .map_err(|e| anyhow!("button pressed handler rejected the request"))?;
+    .map_err(|err| anyhow!("button pressed handler rejected the request: {:?}", err))?;
 
     // todo: this is pretty silly, since every button press will trigger a full ui resyn, really
     // this should be smart and only resync if there are changes