feat: add optional auto-approve config on no approver

.env.example

@@ -1 +1,2 @@
 PHANTASM_SECRET=xxx
+PHANTASM_AUTO_APPROVE=xxx

docs/docs/configuration.md

@@ -28,3 +28,19 @@ communicate with the Receiver Server.
     from phantasmpy import Phantasm
     phantasm = Phantasm(secret="secretkey")
     ```
+
+## Auto Approval
+
+There are times when an approver is not available to approve an action call. By
+default, Phantasm will return an error response with unavailable status code. If
+you want to automatically approve all actions when no approver is available, you
+can enable the auto-approval feature by setting the `PHANTASM_AUTO_APPROVAL`
+environment variable to true.
+
+```bash
+docker run -e PHANTASM_AUTO_APPROVAL=true ...
+```
+
+!!! warning
+
+    Enabling auto-approval is not recommended for production environments.

src/main.rs

@@ -7,7 +7,7 @@ mod types;
 use clap::{arg, ArgMatches, Command};
 use futures::{SinkExt, StreamExt};
 use protos::receiver_server::ReceiverServer;
-use services::Phantasm;
+use services::{Configuration, Phantasm};
 use std::env;
 use std::net::{IpAddr, Ipv4Addr};
 use std::sync::Arc;
@@ -56,12 +56,22 @@ fn start_command() -> Command {
         .arg(arg_coordinator_port)
 }
 
+fn configuration() -> Configuration {
+    let auto_approve = env::var("PHANTASM_AUTO_APPROVE")
+        .map(|value| value.parse::<bool>().unwrap_or_default())
+        .unwrap_or_default();
+
+    Configuration { auto_approve }
+}
+
 async fn start_handler(args: &ArgMatches) {
     // Unwrapping is safe here because the arguments are validated by Clap.
     let receiver_port = *args.get_one::<u16>("receiver-port").unwrap();
     let coordinator_port = *args.get_one::<u16>("coordinator-port").unwrap();
 
-    let service = Arc::new(Phantasm::open().expect("Failed to open Phantasm"));
+    let config = configuration();
+    let phantasm = Phantasm::open(&config).expect("Failed to open Phantasm");
+    let service = Arc::new(phantasm);
 
     let receiver_service = service.clone();
     let receiver_server = tokio::spawn(async move {

src/services/mod.rs

@@ -11,15 +11,29 @@ use tokio::sync::oneshot::Sender;
 use tokio_tungstenite::tungstenite::Message;
 use tonic::{Request, Response, Status};
 
+#[derive(Debug, Clone)]
+pub struct Configuration {
+    pub auto_approve: bool,
+}
+
+#[cfg(test)]
+impl Default for Configuration {
+    fn default() -> Self {
+        Configuration { auto_approve: false }
+    }
+}
+
 #[derive(Debug)]
 pub struct Phantasm {
+    config: Configuration,
     connections: Mutex<HashMap<ConnectionID, Connection>>,
     approvals: Mutex<HashMap<ApprovalID, Sender<ApprovalResponse>>>,
 }
 
 impl Phantasm {
-    pub fn open() -> Result<Self, Box<dyn Error>> {
+    pub fn open(config: &Configuration) -> Result<Self, Box<dyn Error>> {
         Ok(Phantasm {
+            config: config.clone(),
             connections: Mutex::new(HashMap::new()),
             approvals: Mutex::new(HashMap::new()),
         })
@@ -112,7 +126,8 @@ mod tests {
 
     #[tokio::test]
     async fn test_receive_message() {
-        let phantasm = Phantasm::open().unwrap();
+        let config = Configuration::default();
+        let phantasm = Phantasm::open(&config).unwrap();
 
         // Simulate queueing a pending approval request.
         let approval_id = ApprovalID::new();

src/services/receiver.rs

@@ -19,17 +19,25 @@ impl Receiver for Arc<Phantasm> {
         &self,
         request: Request<protos::GetApprovalRequest>,
     ) -> Result<Response<protos::GetApprovalResponse>, Status> {
+        let request = request.into_inner();
         let connection_id = match self.get_lightest_connection() {
             Some(id) => id,
             None => {
-                let message = "No approver is available at the moment";
-                return Err(Status::unavailable(message));
+                if self.config.auto_approve {
+                    return Ok(Response::new(protos::GetApprovalResponse {
+                        approved: true,
+                        parameters: request.parameters.clone(),
+                    }));
+                } else {
+                    let message = "No approver is available at the moment";
+                    return Err(Status::unavailable(message));
+                }
             },
         };
 
         // Unwrap is safe because the connection ID is guaranteed to exist.
         let connection = self.get_connection(&connection_id).unwrap();
-        let message = ApprovalRequest::from(request.into_inner());
+        let message = ApprovalRequest::from(request);
         let approval_id = message.id;
         tracing::info!("An approval request is created: {approval_id}");
 
@@ -72,7 +80,8 @@ mod tests {
 
     #[tokio::test]
     async fn test_heartbeat() {
-        let phantasm = Phantasm::open().unwrap();
+        let config = Configuration::default();
+        let phantasm = Phantasm::open(&config).unwrap();
         let service = Arc::new(phantasm);
 
         let request = Request::new(());