feat: add python feature gate

Disabling the python features removes the dependency on Python
libraries. Effects defined using a Python script will not be loaded if
this feature is disabled.

Fixes #2.

Author: alixinne

Cargo.toml

@@ -40,8 +40,8 @@ parse-display = "0.5"
 paw = "1.0"
 pnet = "0.28"
 prost = "0.7"
-pyo3 = "0.14"
-pythonize = "0.14"
+pyo3 = { version = "0.14", optional = true }
+pythonize = { version = "0.14", optional = true }
 regex = "1.5"
 serde = "1.0"
 serde_derive = "1.0"
@@ -71,3 +71,7 @@ prost-build = "0.7"
 [dev-dependencies]
 criterion = "0.3"
 rand = "0.8"
+
+[features]
+default = ["python"]
+python = ["pyo3", "pythonize"]

README.md

@@ -30,7 +30,8 @@ Currently implemented features:
 * JSON, Protobuf, Flatbuffers and Boblight server
 * Black border detector, color channel adjustments, smoothing
 * Basic effect support (only setColor and setImage, no custom smoothing, no
-  per-instance effect directory)
+  per-instance effect directory). Can be disabled if Python is not available
+  for the target platform (see the `python` feature).
 
 Extra features not available in hyperion.ng:
 

src/effects.rs

@@ -11,11 +11,14 @@ use crate::{global::InputSourceError, image::RawImage, models::Color};
 mod definition;
 pub use definition::*;
 
-mod runtime;
+mod providers;
+pub use providers::Providers;
 
 mod instance;
 use instance::*;
 
+use self::providers::{Provider, ProviderError};
+
 pub struct EffectRunHandle {
     ctx: Sender<ControlMessage>,
     join_handle: Option<JoinHandle<()>>,
@@ -69,52 +72,141 @@ pub enum EffectMessageKind {
     SetColor { color: Color },
     SetImage { image: Arc<RawImage> },
     SetLedColors { colors: Arc<Vec<Color>> },
-    Completed { result: Result<(), pyo3::PyErr> },
+    Completed { result: Result<(), ProviderError> },
+}
+
+#[derive(Default, Debug, Clone)]
+pub struct EffectRegistry {
+    effects: Vec<EffectHandle>,
 }
 
-pub fn run<X: std::fmt::Debug + Clone + Send + 'static>(
-    effect: &EffectDefinition,
-    args: serde_json::Value,
-    led_count: usize,
-    duration: Option<chrono::Duration>,
-    priority: i32,
-    tx: Sender<EffectMessage<X>>,
-    extra: X,
-) -> Result<EffectRunHandle, RunEffectError> {
-    // Resolve path
-    let full_path = effect.script_path()?;
-
-    // Create control channel
-    let (ctx, crx) = channel(1);
-
-    // Create instance methods
-    let methods = InstanceMethods::new(
-        tx.clone(),
-        crx,
-        led_count,
-        duration.and_then(|d| d.to_std().ok()),
-        extra.clone(),
-    );
-
-    // Run effect
-    let join_handle = tokio::task::spawn(async move {
-        // Run the blocking task
-        let result = tokio::task::spawn_blocking(move || runtime::run(&full_path, args, methods))
+impl EffectRegistry {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &EffectDefinition> {
+        self.effects.iter().map(|handle| &handle.definition)
+    }
+
+    pub fn find_effect(&self, name: &str) -> Option<&EffectHandle> {
+        self.effects.iter().find(|e| e.definition.name == name)
+    }
+
+    pub fn len(&self) -> usize {
+        self.effects.len()
+    }
+
+    /// Add definitions to this registry
+    ///
+    /// # Parameters
+    ///
+    /// * `providers`: effect providers
+    /// * `definitions`: effect definitions to register
+    ///
+    /// # Returns
+    ///
+    /// Effect definitions that are not supported by any provider.
+    pub fn add_definitions(
+        &mut self,
+        providers: &Providers,
+        definitions: Vec<EffectDefinition>,
+    ) -> Vec<EffectDefinition> {
+        let mut remaining = vec![];
+
+        for definition in definitions {
+            if let Some(provider) = providers.get(&definition.script) {
+                debug!(provider=?provider, effect=%definition.name, "assigned provider to effect");
+
+                self.effects.push(EffectHandle {
+                    definition,
+                    provider,
+                });
+            } else {
+                debug!(effect=%definition.name, "no provider for effect");
+
+                remaining.push(definition);
+            }
+        }
+
+        remaining
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct EffectHandle {
+    pub definition: EffectDefinition,
+    provider: Arc<dyn Provider>,
+}
+
+impl EffectHandle {
+    pub fn run<X: std::fmt::Debug + Clone + Send + 'static>(
+        &self,
+        args: serde_json::Value,
+        led_count: usize,
+        duration: Option<chrono::Duration>,
+        priority: i32,
+        tx: Sender<EffectMessage<X>>,
+        extra: X,
+    ) -> Result<EffectRunHandle, RunEffectError> {
+        // Resolve path
+        let full_path = self.definition.script_path()?;
+
+        // Clone provider arc
+        let provider = self.provider.clone();
+
+        // Create control channel
+        let (ctx, crx) = channel(1);
+
+        // Create channel to wrap data
+        let (etx, mut erx) = channel(1);
+
+        // Create instance methods
+        let methods =
+            InstanceMethods::new(etx, crx, led_count, duration.and_then(|d| d.to_std().ok()));
+
+        // Run effect
+        let join_handle = tokio::task::spawn(async move {
+            // Create the blocking task
+            let mut run_effect =
+                tokio::task::spawn_blocking(move || provider.run(&full_path, args, methods));
+
+            // Join the blocking task while forwarding the effect messages
+            let result = loop {
+                tokio::select! {
+                    kind = erx.recv() => {
+                        if let Some(kind) = kind {
+                            // Add the extra marker to the message and forward it to the instance
+                            let msg = EffectMessage { kind, extra: extra.clone() };
+
+                            if let Err(err) = tx.send(msg).await {
+                                // This would happen if the effect is running and the instance has
+                                // already shutdown.
+                                error!(err=%err, "failed to forward effect message");
+                                return;
+                            }
+                        }
+                    }
+                    result = &mut run_effect => {
+                        // Unwrap blocking result
+                        break result.expect("failed to await blocking task");
+                    }
+                }
+            };
+
+            // Send the completion, ignoring failures in case we're shutting down
+            tx.send(EffectMessage {
+                kind: EffectMessageKind::Completed { result },
+                extra,
+            })
             .await
-            .expect("failed to await blocking task");
+            .ok();
+        });
 
-        // Send the completion, ignoring failures in case we're shutting down
-        tx.send(EffectMessage {
-            kind: EffectMessageKind::Completed { result },
-            extra,
+        Ok(EffectRunHandle {
+            ctx,
+            join_handle: join_handle.into(),
+            priority,
         })
-        .await
-        .ok();
-    });
-
-    Ok(EffectRunHandle {
-        ctx,
-        join_handle: join_handle.into(),
-        priority,
-    })
+    }
 }

src/effects/instance.rs

@@ -3,44 +3,42 @@ use std::{
     time::{Duration, Instant},
 };
 
+use thiserror::Error;
 use tokio::sync::mpsc::{Receiver, Sender};
 
-use crate::image::RawImage;
-
-use super::{
-    runtime::{RuntimeMethodError, RuntimeMethods},
-    EffectMessage, EffectMessageKind,
+use crate::{
+    image::{RawImage, RawImageError},
+    models::Color,
 };
 
+use super::EffectMessageKind;
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum ControlMessage {
     Abort,
 }
 
-pub struct InstanceMethods<X> {
-    tx: Sender<EffectMessage<X>>,
+pub struct InstanceMethods {
+    tx: Sender<EffectMessageKind>,
     crx: RefCell<Receiver<ControlMessage>>,
     led_count: usize,
     deadline: Option<Instant>,
     aborted: Cell<bool>,
-    extra: X,
 }
 
-impl<X> InstanceMethods<X> {
+impl InstanceMethods {
     pub fn new(
-        tx: Sender<EffectMessage<X>>,
+        tx: Sender<EffectMessageKind>,
         crx: Receiver<ControlMessage>,
         led_count: usize,
         duration: Option<Duration>,
-        extra: X,
     ) -> Self {
         Self {
             tx,
             crx: crx.into(),
             led_count,
             deadline: duration.map(|d| Instant::now() + d),
             aborted: false.into(),
-            extra,
         }
     }
 
@@ -93,7 +91,7 @@ impl<X> InstanceMethods<X> {
     }
 }
 
-impl<X: std::fmt::Debug + Clone> RuntimeMethods for InstanceMethods<X> {
+impl RuntimeMethods for InstanceMethods {
     fn get_led_count(&self) -> usize {
         self.led_count
     }
@@ -105,31 +103,51 @@ impl<X: std::fmt::Debug + Clone> RuntimeMethods for InstanceMethods<X> {
     fn set_color(&self, color: crate::models::Color) -> Result<(), RuntimeMethodError> {
         self.poll_control()?;
 
-        self.wrap_result(self.tx.blocking_send(EffectMessage {
-            kind: EffectMessageKind::SetColor { color },
-            extra: self.extra.clone(),
-        }))
+        self.wrap_result(self.tx.blocking_send(EffectMessageKind::SetColor { color }))
     }
 
     fn set_led_colors(&self, colors: Vec<crate::models::Color>) -> Result<(), RuntimeMethodError> {
         self.poll_control()?;
 
-        self.wrap_result(self.tx.blocking_send(EffectMessage {
-            kind: EffectMessageKind::SetLedColors {
-                colors: colors.into(),
-            },
-            extra: self.extra.clone(),
+        self.wrap_result(self.tx.blocking_send(EffectMessageKind::SetLedColors {
+            colors: colors.into(),
         }))
     }
 
     fn set_image(&self, image: RawImage) -> Result<(), RuntimeMethodError> {
         self.poll_control()?;
 
-        self.wrap_result(self.tx.blocking_send(EffectMessage {
-            kind: EffectMessageKind::SetImage {
-                image: image.into(),
-            },
-            extra: self.extra.clone(),
+        self.wrap_result(self.tx.blocking_send(EffectMessageKind::SetImage {
+            image: image.into(),
         }))
     }
 }
+
+pub trait RuntimeMethods {
+    fn get_led_count(&self) -> usize;
+    fn abort(&self) -> bool;
+
+    fn set_color(&self, color: Color) -> Result<(), RuntimeMethodError>;
+    fn set_led_colors(&self, colors: Vec<Color>) -> Result<(), RuntimeMethodError>;
+    fn set_image(&self, image: RawImage) -> Result<(), RuntimeMethodError>;
+}
+
+#[derive(Debug, Error)]
+pub enum RuntimeMethodError {
+    #[cfg(feature = "python")]
+    #[error("Invalid arguments to hyperion.{name}")]
+    InvalidArguments { name: &'static str },
+    #[cfg(feature = "python")]
+    #[error("Length of bytearray argument should be 3*ledCount")]
+    InvalidByteArray,
+    #[error("Effect aborted")]
+    EffectAborted,
+    #[error(transparent)]
+    InvalidImageData(#[from] RawImageError),
+}
+
+impl<T> From<tokio::sync::mpsc::error::SendError<T>> for RuntimeMethodError {
+    fn from(_: tokio::sync::mpsc::error::SendError<T>) -> Self {
+        Self::EffectAborted
+    }
+}