Implement a transactional actor

2025-01/transactional-actor/Cargo.toml

@@ -5,5 +5,6 @@ edition = "2021"
 
 [dependencies]
 anyhow = "1.0.95"
+async-trait = "0.1.85"
 crb = "0.0.27"
 tokio = "1.43.0"

2025-01/transactional-actor/src/main.rs

@@ -1 +1,73 @@
-fn main() {}
+use anyhow::Result;
+use async_trait::async_trait;
+use crb::agent::{Agent, AgentSession, Context, DoAsync, DoSync, Duty, Next, OnEvent, Runnable};
+use crb::core::time::Duration;
+use crb::superagent::TimeoutSwitch;
+
+struct Tractor {
+    timeout: TimeoutSwitch<Tick>,
+}
+
+impl Tractor {
+    fn new() -> Self {
+        let duration = Duration::from_secs(1);
+        Self {
+            timeout: TimeoutSwitch::new(duration, Tick),
+        }
+    }
+}
+
+impl Agent for Tractor {
+    type Context = AgentSession<Self>;
+
+    fn begin(&mut self) -> Next<Self> {
+        Next::duty(Initialize)
+    }
+}
+
+struct Initialize;
+
+#[async_trait]
+impl Duty<Initialize> for Tractor {
+    async fn handle(&mut self, _: Initialize, ctx: &mut Context<Self>) -> Result<Next<Self>> {
+        println!("Initialize");
+        self.timeout.add_listener(ctx);
+        self.timeout.start();
+        Ok(Next::events())
+    }
+}
+
+#[derive(Clone)]
+struct Tick;
+
+#[async_trait]
+impl OnEvent<Tick> for Tractor {
+    async fn handle(&mut self, _: Tick, ctx: &mut Context<Self>) -> Result<()> {
+        println!("Tick");
+        ctx.do_next(Next::do_async(()));
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl DoAsync for Tractor {
+    async fn once(&mut self, _: &mut ()) -> Result<Next<Self>> {
+        println!("Async");
+        Ok(Next::do_sync(()))
+    }
+}
+
+impl DoSync for Tractor {
+    fn once(&mut self, _: &mut ()) -> Result<Next<Self>> {
+        println!("Sync");
+        Ok(Next::done())
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    println!("Begin");
+    Tractor::new().run().await?;
+    println!("End");
+    Ok(())
+}