feat(api): JSON API

Author: alixinne

Cargo.lock

@@ -42,6 +42,7 @@ sqlx = { version = "0.5", features = ["sqlite", "runtime-tokio-rustls"] }
 structopt = { version = "0.3", features = ["paw"] }
 strum = "0.20"
 strum_macros = "0.20"
+sysinfo = { version = "0.18", default-features = false }
 thiserror = "1.0"
 tokio = { version = "1", features = ["macros", "net", "rt-multi-thread", "signal", "sync", "time"] }
 tokio-util = { version = "0.6", features = ["codec"] }

Cargo.toml

@@ -5,6 +5,7 @@ use std::sync::Arc;
 use thiserror::Error;
 
 use crate::{
+    component::ComponentName,
     global::{Global, InputMessage, InputMessageData, InputSourceHandle, InputSourceName},
     image::{RawImage, RawImageError},
     models::Color,
@@ -43,11 +44,14 @@ pub async fn handle_request(
         if let Some(clear) = request.command_as_clear() {
             // Update state
             if clear.priority() < 0 {
-                source.send(InputMessageData::ClearAll)?;
+                source.send(ComponentName::FlatbufServer, InputMessageData::ClearAll)?;
             } else {
-                source.send(InputMessageData::Clear {
-                    priority: clear.priority(),
-                })?;
+                source.send(
+                    ComponentName::FlatbufServer,
+                    InputMessageData::Clear {
+                        priority: clear.priority(),
+                    },
+                )?;
             }
         } else if let Some(color) = request.command_as_color() {
             let rgb = color.data();
@@ -58,12 +62,15 @@ pub async fn handle_request(
             );
 
             // Update state
-            source.send(InputMessageData::SolidColor {
-                // TODO
-                priority: 0,
-                duration: i32_to_duration(Some(color.duration())),
-                color: Color::from_components(rgb),
-            })?;
+            source.send(
+                ComponentName::FlatbufServer,
+                InputMessageData::SolidColor {
+                    // TODO
+                    priority: 0,
+                    duration: i32_to_duration(Some(color.duration())),
+                    color: Color::from_components(rgb),
+                },
+            )?;
         } else if let Some(image) = request.command_as_image() {
             // Get raw image
             let data = image
@@ -82,11 +89,14 @@ pub async fn handle_request(
             let raw_image = RawImage::try_from((data.to_vec(), width, height))?;
 
             // Update state
-            source.send(InputMessageData::Image {
-                priority,
-                duration: i32_to_duration(Some(duration)),
-                image: Arc::new(raw_image),
-            })?;
+            source.send(
+                ComponentName::FlatbufServer,
+                InputMessageData::Image {
+                    priority,
+                    duration: i32_to_duration(Some(duration)),
+                    image: Arc::new(raw_image),
+                },
+            )?;
         } else if let Some(_) = request.command_as_register() {
             return Err(FlatApiError::AlreadyRegistered);
         } else {

src/api/flat.rs

@@ -5,6 +5,7 @@ use thiserror::Error;
 use validator::Validate;
 
 use crate::{
+    component::ComponentName,
     global::{Global, InputMessage, InputMessageData, InputSourceHandle},
     image::{RawImage, RawImageError},
 };
@@ -47,12 +48,14 @@ impl ClientConnection {
         match request.command {
             HyperionCommand::ClearAll => {
                 // Update state
-                self.source.send(InputMessageData::ClearAll)?;
+                self.source
+                    .send(ComponentName::All, InputMessageData::ClearAll)?;
             }
 
             HyperionCommand::Clear(message::Clear { priority }) => {
                 // Update state
-                self.source.send(InputMessageData::Clear { priority })?;
+                self.source
+                    .send(ComponentName::All, InputMessageData::Clear { priority })?;
             }
 
             HyperionCommand::Color(message::Color {
@@ -64,11 +67,14 @@ impl ClientConnection {
                 // TODO: Handle origin field
 
                 // Update state
-                self.source.send(InputMessageData::SolidColor {
-                    priority,
-                    duration: duration.map(|ms| chrono::Duration::milliseconds(ms as _)),
-                    color,
-                })?;
+                self.source.send(
+                    ComponentName::Color,
+                    InputMessageData::SolidColor {
+                        priority,
+                        duration: duration.map(|ms| chrono::Duration::milliseconds(ms as _)),
+                        color,
+                    },
+                )?;
             }
 
             HyperionCommand::Image(message::Image {
@@ -86,44 +92,55 @@ impl ClientConnection {
 
                 let raw_image = RawImage::try_from((imagedata, imagewidth, imageheight))?;
 
-                self.source.send(InputMessageData::Image {
-                    priority,
-                    duration: duration.map(|ms| chrono::Duration::milliseconds(ms as _)),
-                    image: Arc::new(raw_image),
-                })?;
+                self.source.send(
+                    ComponentName::Image,
+                    InputMessageData::Image {
+                        priority,
+                        duration: duration.map(|ms| chrono::Duration::milliseconds(ms as _)),
+                        image: Arc::new(raw_image),
+                    },
+                )?;
             }
 
             HyperionCommand::ServerInfo(message::ServerInfoRequest { subscribe: _ }) => {
                 // TODO: Handle subscribe field
 
                 // Request priority information
                 let (sender, receiver) = tokio::sync::oneshot::channel();
-                self.source.send(InputMessageData::PrioritiesRequest {
-                    response: Arc::new(std::sync::Mutex::new(Some(sender))),
-                })?;
+                self.source.send(
+                    ComponentName::All,
+                    InputMessageData::PrioritiesRequest {
+                        response: Arc::new(std::sync::Mutex::new(Some(sender))),
+                    },
+                )?;
 
                 // Receive priority information
-                let priorities = receiver
-                    .await?
-                    .into_iter()
-                    .map(message::PriorityInfo::from)
-                    .collect();
+                let priorities = receiver.await?.into_iter().collect();
 
                 // Just answer the serverinfo request, no need to update state
-                return Ok(Some(HyperionResponse::server_info(
-                    request.tan,
-                    vec![],
-                    priorities,
+
+                return Ok(Some(
                     global
                         .read_config(|config| {
-                            config
+                            let instances = config
                                 .instances
                                 .iter()
                                 .map(|instance_config| (&instance_config.1.instance).into())
-                                .collect()
+                                .collect();
+
+                            HyperionResponse::server_info(
+                                request.tan,
+                                // TODO: Priorities only for current instance
+                                priorities,
+                                // TODO: Fill adjustments
+                                vec![],
+                                // TODO: Fill effects
+                                vec![],
+                                instances,
+                            )
                         })
                         .await,
-                )));
+                ));
             }
 
             HyperionCommand::Authorize(message::Authorize { subcommand, .. }) => match subcommand {