SQLite engine: scheduler + outbox — schedule/unschedule/run_schedules leader loop, outbox enqueue/run_once (task sqlite-engine-scheduler-outbox)

alkstore-sqlite/src/store.rs

@@ -188,13 +188,15 @@ impl Store for SqliteStore {
 
     fn outbox<'a>(
         &'a self,
-        _name: &str,
+        name: &str,
     ) -> alkstore::BoxedFuture<'a, alkstore::Result<Box<dyn alkstore::Outbox>>> {
-        Box::pin(async {
-            Err(database_error(
-                "outbox wiring lands with the mechanism tasks",
-            ))
-        })
+        if self.closed.load(std::sync::atomic::Ordering::Acquire) {
+            return Box::pin(async { Err(crate::seam::closed_store_error()) });
+        }
+        let name = name.to_string();
+        let writer = self.writer.clone();
+        let closed = self.closed.clone();
+        Box::pin(async move { crate::outbox::new_outbox_handle(&name, writer, closed) })
     }
 
     fn try_lock<'a>(
@@ -212,36 +214,34 @@ impl Store for SqliteStore {
 
     fn schedule<'a>(
         &'a self,
-        _name: &str,
-        _spec: &str,
-        _queue: &str,
-        _payload: serde_json::Value,
-        _opts: alkstore::ScheduleOpts,
+        name: &str,
+        spec: &str,
+        queue: &str,
+        payload: serde_json::Value,
+        opts: alkstore::ScheduleOpts,
     ) -> alkstore::BoxedFuture<'a, alkstore::Result<alkstore::Schedule>> {
-        Box::pin(async {
-            Err(database_error(
-                "schedule wiring lands with the mechanism tasks",
-            ))
-        })
+        let writer = self.writer.clone();
+        let closed = self.closed.clone();
+        let name = name.to_string();
+        let spec = spec.to_string();
+        let queue = queue.to_string();
+        crate::scheduler::schedule(&name, &spec, &queue, payload, opts, writer, closed)
     }
 
-    fn unschedule<'a>(&'a self, _name: &str) -> alkstore::BoxedFuture<'a, alkstore::Result<bool>> {
-        Box::pin(async {
-            Err(database_error(
-                "unschedule wiring lands with the mechanism tasks",
-            ))
-        })
+    fn unschedule<'a>(&'a self, name: &str) -> alkstore::BoxedFuture<'a, alkstore::Result<bool>> {
+        let writer = self.writer.clone();
+        let closed = self.closed.clone();
+        let name = name.to_string();
+        crate::scheduler::unschedule(&name, writer, closed)
     }
 
     fn run_schedules<'a>(
         &'a self,
-        _stop: alkstore::StopToken,
+        stop: alkstore::StopToken,
     ) -> alkstore::BoxedFuture<'a, alkstore::Result<()>> {
-        Box::pin(async {
-            Err(database_error(
-                "scheduler wiring lands with the mechanism tasks",
-            ))
-        })
+        let writer = self.writer.clone();
+        let closed = self.closed.clone();
+        crate::scheduler::run_schedules(stop, writer, closed)
     }
 }
 
@@ -252,8 +252,12 @@ mod notify_tests;
 #[cfg(test)]
 mod open_tests;
 #[cfg(test)]
+mod outbox_tests;
+#[cfg(test)]
 mod queue_tests;
 #[cfg(test)]
+mod scheduler_tests;
+#[cfg(test)]
 mod stream_tests;
 #[cfg(test)]
 mod tx_tests;