Add calling of supervisor over mycelium

Signed-off-by: Lee Smet <lee.smet@hotmail.com>

src/storage/redis.rs

@@ -163,7 +163,11 @@ impl RedisDriver {
             .and_then(|v| v.as_u64())
             .ok_or("Context.id missing or not a number")? as u32;
         let key = Self::context_key(id);
-        self.hset_model(id, &key, ctx).await
+        // Write the context hash in its own DB
+        self.hset_model(id, &key, ctx).await?;
+        // Register this context id in the global registry (DB 0)
+        let _ = self.register_context_id(id).await;
+        Ok(())
     }
 
     /// Load a Context from its own DB (db index = id)
@@ -551,4 +555,70 @@ impl RedisDriver {
         let key = Self::message_key(caller_id, id);
         self.lpush_list(db, "msg_out", &key).await
     }
+
+    /// Block-pop from msg_out with timeout (seconds). Returns the message key if present.
+    /// Uses BRPOP so that the queue behaves FIFO with LPUSH producer.
+    pub async fn brpop_msg_out(&self, db: u32, timeout_secs: usize) -> Result<Option<String>> {
+        let mut cm = self.manager_for_db(db).await?;
+        // BRPOP returns (list, element) on success
+        let res: Option<(String, String)> = redis::cmd("BRPOP")
+            .arg("msg_out")
+            .arg(timeout_secs)
+            .query_async(&mut cm)
+            .await?;
+        Ok(res.map(|(_, v)| v))
+    }
+
+    /// Scan all runner:* keys in this DB and return the deserialized Runner entries.
+    pub async fn scan_runners(&self, db: u32) -> Result<Vec<Runner>> {
+        let mut cm = self.manager_for_db(db).await?;
+        let mut out: Vec<Runner> = Vec::new();
+        let mut cursor: u64 = 0;
+        loop {
+            let (next, keys): (u64, Vec<String>) = redis::cmd("SCAN")
+                .arg(cursor)
+                .arg("MATCH")
+                .arg("runner:*")
+                .arg("COUNT")
+                .arg(100)
+                .query_async(&mut cm)
+                .await?;
+            for k in keys {
+                if let Ok(r) = self.hget_model::<Runner>(db, &k).await {
+                    out.push(r);
+                }
+            }
+            if next == 0 {
+                break;
+            }
+            cursor = next;
+        }
+        Ok(out)
+    }
+
+    // -----------------------------
+    // Global registry (DB 0) for Context IDs
+    // -----------------------------
+
+    /// Register a context id in the global set "contexts" stored in DB 0.
+    pub async fn register_context_id(&self, id: u32) -> Result<()> {
+        let mut cm = self.manager_for_db(0).await?;
+        let _: i64 = redis::cmd("SADD").arg("contexts").arg(id).query_async(&mut cm).await?;
+        Ok(())
+    }
+
+    /// List all registered context ids from the global set in DB 0.
+    pub async fn list_context_ids(&self) -> Result<Vec<u32>> {
+        let mut cm = self.manager_for_db(0).await?;
+        // Using SMEMBERS and parsing into u32
+        let vals: Vec<String> = redis::cmd("SMEMBERS").arg("contexts").query_async(&mut cm).await?;
+        let mut out = Vec::with_capacity(vals.len());
+        for v in vals {
+            if let Ok(n) = v.parse::<u32>() {
+                out.push(n);
+            }
+        }
+        out.sort_unstable();
+        Ok(out)
+    }
 }