feat(api): Return priorities of current instance in JSON API

Author: alixinne

src/api/json.rs

@@ -8,6 +8,7 @@ use crate::{
     component::ComponentName,
     global::{Global, InputMessage, InputMessageData, InputSourceHandle},
     image::{RawImage, RawImageError},
+    instance::InstanceHandle,
 };
 
 /// Schema definitions as Serde serializable structures and enums
@@ -31,15 +32,42 @@ pub enum JsonApiError {
 /// A client connected to the JSON endpoint
 pub struct ClientConnection {
     source: InputSourceHandle<InputMessage>,
+    current_instance: Option<i32>,
 }
 
 impl ClientConnection {
     pub fn new(source: InputSourceHandle<InputMessage>) -> Self {
-        Self { source }
+        Self {
+            source,
+            current_instance: None,
+        }
+    }
+
+    async fn current_instance(&mut self, global: &Global) -> Option<InstanceHandle> {
+        if let Some(current_instance) = self.current_instance {
+            if let Some(instance) = global.get_instance(current_instance).await {
+                return Some(instance);
+            } else {
+                // Instance id now invalid, reset
+                self.current_instance = None;
+            }
+        }
+
+        if let Some((id, inst)) = global.default_instance().await {
+            self.set_current_instance(id);
+            return Some(inst);
+        }
+
+        None
+    }
+
+    fn set_current_instance(&mut self, id: i32) {
+        debug!("{}: switch to instance {}", &self.source.name(), id);
+        self.current_instance = Some(id);
     }
 
     pub async fn handle_request(
-        &self,
+        &mut self,
         request: HyperionMessage,
         global: &Global,
     ) -> Result<Option<HyperionResponse>, JsonApiError> {
@@ -105,6 +133,12 @@ impl ClientConnection {
             HyperionCommand::ServerInfo(message::ServerInfoRequest { subscribe: _ }) => {
                 // TODO: Handle subscribe field
 
+                let priorities = if let Some(handle) = self.current_instance(global).await {
+                    handle.current_priorities().await
+                } else {
+                    vec![]
+                };
+
                 // Just answer the serverinfo request, no need to update state
                 return Ok(Some(
                     global
@@ -117,8 +151,7 @@ impl ClientConnection {
 
                             HyperionResponse::server_info(
                                 request.tan,
-                                // TODO: Priorities only for current instance
-                                vec![],
+                                priorities,
                                 // TODO: Fill adjustments
                                 vec![],
                                 // TODO: Fill effects
@@ -147,6 +180,21 @@ impl ClientConnection {
                 )));
             }
 
+            HyperionCommand::Instance(message::Instance {
+                subcommand: message::InstanceCommand::SwitchTo,
+                instance: Some(id),
+                ..
+            }) => {
+                if global.get_instance(id).await.is_some() {
+                    self.set_current_instance(id);
+                    return Ok(Some(HyperionResponse::switch_to(request.tan, Some(id))));
+                } else {
+                    // Note: it's an "Ok" but should be an Err. Find out how to represent errors
+                    // better
+                    return Ok(Some(HyperionResponse::switch_to(request.tan, None)));
+                }
+            }
+
             _ => return Err(JsonApiError::NotImplemented),
         };
 

src/api/json/message.rs

@@ -230,8 +230,8 @@ pub enum InstanceCommand {
 #[derive(Debug, Deserialize, Validate)]
 pub struct Instance {
     pub subcommand: InstanceCommand,
-    #[validate(range(max = 255))]
-    pub instance: Option<u32>,
+    #[validate(range(min = 0, max = 255))]
+    pub instance: Option<i32>,
     #[validate(length(min = 5))]
     pub name: Option<String>,
 }
@@ -675,6 +675,12 @@ pub enum HyperionResponseInfo {
     /// SysInfo response
     #[serde(rename = "sysinfo")]
     SysInfo(SysInfo),
+    /// SwitchTo response
+    #[serde(rename = "instance-switchTo")]
+    SwitchTo {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        instance: Option<i32>,
+    },
 }
 
 impl HyperionResponse {
@@ -698,7 +704,7 @@ impl HyperionResponse {
     }
 
     /// Return an error response
-    pub fn error(tan: Option<i32>, error: &impl std::fmt::Display) -> Self {
+    pub fn error(tan: Option<i32>, error: impl std::fmt::Display) -> Self {
         Self {
             success: false,
             tan,
@@ -707,6 +713,20 @@ impl HyperionResponse {
         }
     }
 
+    /// Return an error response
+    pub fn error_info(
+        tan: Option<i32>,
+        error: impl std::fmt::Display,
+        info: HyperionResponseInfo,
+    ) -> Self {
+        Self {
+            success: false,
+            tan,
+            error: Some(error.to_string()),
+            info: Some(info),
+        }
+    }
+
     /// Return a server information response
     pub fn server_info(
         tan: Option<i32>,
@@ -741,6 +761,19 @@ impl HyperionResponse {
         // TODO: Properly fill out this response
         Self::success_info(tan, HyperionResponseInfo::SysInfo(SysInfo::new(id)))
     }
+
+    pub fn switch_to(tan: Option<i32>, id: Option<i32>) -> Self {
+        if let Some(id) = id {
+            // Switch successful
+            Self::success_info(tan, HyperionResponseInfo::SwitchTo { instance: Some(id) })
+        } else {
+            Self::error_info(
+                tan,
+                "selected hyperion instance not found",
+                HyperionResponseInfo::SwitchTo { instance: None },
+            )
+        }
+    }
 }
 
 fn hostname() -> String {

src/global.rs

@@ -83,6 +83,16 @@ impl Global {
         self.0.read().await.instances.get(&id).cloned()
     }
 
+    pub async fn default_instance(&self) -> Option<(i32, InstanceHandle)> {
+        self.0
+            .read()
+            .await
+            .instances
+            .iter()
+            .next()
+            .map(|(k, v)| (*k, v.clone()))
+    }
+
     pub async fn read_config<T>(&self, f: impl FnOnce(&Config) -> T) -> T {
         let data = self.0.read().await;
         f(&data.config)

src/instance.rs

@@ -65,7 +65,7 @@ impl Instance {
         }
 
         let receiver = global.subscribe_input().await;
-        let (tx, local_receiver) = mpsc::channel(4);
+        let (local_tx, local_receiver) = mpsc::channel(4);
 
         let muxer = PriorityMuxer::new(global.clone()).await;
         let core = Core::new(&config).await;
@@ -78,8 +78,10 @@ impl Instance {
                 global.clone(),
                 {
                     let instance = config.clone();
+                    let local_tx = local_tx.clone();
+
                     move |tcp, global| {
-                        servers::boblight::handle_client(tcp, tx.clone(), instance.clone(), global)
+                        servers::boblight::handle_client(tcp, local_tx.clone(), instance.clone(), global)
                     }
                 },
             )
@@ -111,7 +113,7 @@ impl Instance {
                 core,
                 _boblight_server,
             },
-            InstanceHandle { id, tx },
+            InstanceHandle { id, tx, local_tx },
         )
     }
 
@@ -225,6 +227,7 @@ enum InstanceMessage {
 pub struct InstanceHandle {
     id: i32,
     tx: mpsc::Sender<InstanceMessage>,
+    local_tx: mpsc::Sender<InputMessage>,
 }
 
 impl InstanceHandle {
@@ -240,6 +243,7 @@ impl InstanceHandle {
             .send(InstanceMessage::PriorityInfo(tx))
             .await
             .unwrap();
+
         // unwrap: if the previous didn't fail, the instance will be there to answer
         rx.await.unwrap()
     }

src/servers/json.rs

@@ -36,7 +36,7 @@ pub async fn handle_client(
     let (mut writer, mut reader) = framed.split();
 
     // unwrap: cannot fail because the priority is None
-    let client_connection = json::ClientConnection::new(
+    let mut client_connection = json::ClientConnection::new(
         global
             .register_input_source(InputSourceName::Json { peer_addr }, None)
             .await