Implement Commanding (#6)

Reviewed-on: #6
Co-authored-by: Sergey Savelyev <sergeysav.nn@gmail.com>
Co-committed-by: Sergey Savelyev <sergeysav.nn@gmail.com>

server/src/command/service.rs

@@ -0,0 +1,165 @@
+use crate::command::definition::CommandDefinition;
+use crate::command::error::Error as CmdError;
+use crate::command::error::Error::{
+    CommandFailure, CommandNotFound, FailedToReceiveResponse, FailedToSend,
+    IncorrectParameterCount, MisingParameter, NoCommandReceiver, WrongParameterType,
+};
+use crate::core::telemetry_value::Value;
+use crate::core::{
+    Command, CommandDefinitionRequest, CommandResponse, TelemetryDataType, TelemetryValue,
+    Timestamp, Uuid,
+};
+use chrono::{DateTime, Utc};
+use log::error;
+use papaya::HashMap;
+use std::collections::HashMap as StdHashMap;
+use tokio::sync::mpsc;
+use tokio::sync::oneshot;
+
+#[derive(Clone)]
+pub(super) struct RegisteredCommand {
+    pub(super) name: String,
+    pub(super) definition: CommandDefinitionRequest,
+    tx: mpsc::Sender<Option<(Command, oneshot::Sender<CommandResponse>)>>,
+}
+
+pub struct CommandManagementService {
+    registered_commands: HashMap<String, RegisteredCommand>,
+}
+
+impl CommandManagementService {
+    pub fn new() -> Self {
+        Self {
+            registered_commands: HashMap::new(),
+        }
+    }
+
+    pub fn get_commands(&self) -> anyhow::Result<Vec<CommandDefinition>> {
+        let mut result = vec![];
+
+        let registered_commands = self.registered_commands.pin();
+        for registration in registered_commands.values() {
+            result.push(registration.clone().into());
+        }
+
+        Ok(result)
+    }
+
+    pub fn get_command_definition(&self, name: &String) -> Option<CommandDefinition> {
+        self.registered_commands
+            .pin()
+            .get(name)
+            .map(|registration| registration.clone().into())
+    }
+
+    pub async fn register_command(
+        &self,
+        command: CommandDefinitionRequest,
+    ) -> anyhow::Result<mpsc::Receiver<Option<(Command, oneshot::Sender<CommandResponse>)>>> {
+        let (tx, rx) = mpsc::channel(1);
+
+        let registered_commands = self.registered_commands.pin_owned();
+        if let Some(previous) = registered_commands.insert(
+            command.name.clone(),
+            RegisteredCommand {
+                name: command.name.clone(),
+                definition: command,
+                tx,
+            },
+        ) {
+            // If the receiver was already closed, we don't care (ignore error)
+            let _ = previous.tx.send(None).await;
+        }
+
+        Ok(rx)
+    }
+
+    pub async fn send_command(
+        &self,
+        name: impl Into<String>,
+        parameters: serde_json::Map<String, serde_json::Value>,
+    ) -> Result<String, CmdError> {
+        let timestamp = Utc::now();
+        let offset_from_unix_epoch =
+            timestamp - DateTime::from_timestamp(0, 0).expect("Could not get Unix epoch");
+
+        let name = name.into();
+        let registered_commands = self.registered_commands.pin();
+        let Some(registration) = registered_commands.get(&name) else {
+            return Err(CommandNotFound(name));
+        };
+
+        if parameters.len() != registration.definition.parameters.len() {
+            return Err(IncorrectParameterCount {
+                expected: registration.definition.parameters.len(),
+                actual: parameters.len(),
+            });
+        }
+        let mut result_parameters = StdHashMap::new();
+        for parameter in &registration.definition.parameters {
+            let Some(param_value) = parameters.get(&parameter.name) else {
+                return Err(MisingParameter(parameter.name.clone()));
+            };
+            let Some(param_value) = (match parameter.data_type() {
+                TelemetryDataType::Float32 => {
+                    param_value.as_f64().map(|v| Value::Float32(v as f32))
+                }
+                TelemetryDataType::Float64 => param_value.as_f64().map(Value::Float64),
+                TelemetryDataType::Boolean => param_value.as_bool().map(Value::Boolean),
+            }) else {
+                return Err(WrongParameterType {
+                    name: parameter.name.clone(),
+                    expected_type: parameter.data_type(),
+                });
+            };
+            result_parameters.insert(
+                parameter.name.clone(),
+                TelemetryValue {
+                    value: Some(param_value),
+                },
+            );
+        }
+
+        // Clone & Drop lets us use a standard pin instead of an owned pin
+        let tx = registration.tx.clone();
+        drop(registered_commands);
+
+        if tx.is_closed() {
+            return Err(NoCommandReceiver);
+        }
+
+        let uuid = Uuid::random();
+        let (response_tx, response_rx) = oneshot::channel();
+        if let Err(e) = tx
+            .send(Some((
+                Command {
+                    uuid: Some(uuid),
+                    timestamp: Some(Timestamp {
+                        secs: offset_from_unix_epoch.num_seconds(),
+                        nanos: offset_from_unix_epoch.subsec_nanos(),
+                    }),
+                    parameters: result_parameters,
+                },
+                response_tx,
+            )))
+            .await
+        {
+            error!("Failed to Send Command: {e}");
+            return Err(FailedToSend);
+        }
+
+        response_rx
+            .await
+            .map_err(|e| {
+                error!("Failed to Receive Command Response: {e}");
+                FailedToReceiveResponse
+            })
+            .and_then(|response| {
+                if response.success {
+                    Ok(response.response)
+                } else {
+                    Err(CommandFailure(response.response))
+                }
+            })
+    }
+}