Documentation for Rust SDK

examples/services/mod.rs

@@ -0,0 +1,3 @@
+pub mod my_service;
+pub mod my_virtual_object;
+pub mod my_workflow;

examples/services/my_service.rs

@@ -0,0 +1,22 @@
+use restate_sdk::prelude::*;
+
+#[restate_sdk::service]
+pub trait MyService {
+    async fn my_handler(greeting: String) -> Result<String, HandlerError>;
+}
+
+pub struct MyServiceImpl;
+
+impl MyService for MyServiceImpl {
+    async fn my_handler(&self, _ctx: Context<'_>, greeting: String) -> Result<String, HandlerError> {
+        Ok(format!("{greeting}!"))
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt::init();
+    HttpServer::new(Endpoint::builder().bind(MyServiceImpl.serve()).build())
+        .listen_and_serve("0.0.0.0:9080".parse().unwrap())
+        .await;
+}

examples/services/my_virtual_object.rs

@@ -0,0 +1,39 @@
+use restate_sdk::prelude::*;
+
+#[restate_sdk::object]
+pub trait MyVirtualObject {
+    async fn my_handler(name: String) -> Result<String, HandlerError>;
+    #[shared]
+    async fn my_concurrent_handler(name: String) -> Result<String, HandlerError>;
+}
+
+pub struct MyVirtualObjectImpl;
+
+impl MyVirtualObject for MyVirtualObjectImpl {
+    async fn my_handler(
+        &self,
+        ctx: ObjectContext<'_>,
+        greeting: String,
+    ) -> Result<String, HandlerError> {
+        Ok(format!("Greetings {} {}", greeting, ctx.key()))
+    }
+    async fn my_concurrent_handler(
+        &self,
+        ctx: SharedObjectContext<'_>,
+        greeting: String,
+    ) -> Result<String, HandlerError> {
+        Ok(format!("Greetings {} {}", greeting, ctx.key()))
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt::init();
+    HttpServer::new(
+        Endpoint::builder()
+            .bind(MyVirtualObjectImpl.serve())
+            .build(),
+    )
+    .listen_and_serve("0.0.0.0:9080".parse().unwrap())
+    .await;
+}

examples/services/my_workflow.rs

@@ -0,0 +1,35 @@
+use restate_sdk::prelude::*;
+
+#[restate_sdk::workflow]
+pub trait MyWorkflow {
+    async fn run(req: String) -> Result<String, HandlerError>;
+    #[shared]
+    async fn interact_with_workflow() -> Result<(), HandlerError>;
+}
+
+pub struct MyWorkflowImpl;
+
+impl MyWorkflow for MyWorkflowImpl {
+    async fn run(&self, _ctx: WorkflowContext<'_>, _req: String) -> Result<String, HandlerError> {
+        // implement workflow logic here
+
+        Ok(String::from("success"))
+    }
+    async fn interact_with_workflow(
+        &self,
+        _ctx: SharedWorkflowContext<'_>,
+    ) -> Result<(), HandlerError> {
+        // implement interaction logic here
+        // e.g. resolve a promise that the workflow is waiting on
+
+        Ok(())
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt::init();
+    HttpServer::new(Endpoint::builder().bind(MyWorkflowImpl.serve()).build())
+        .listen_and_serve("0.0.0.0:9080".parse().unwrap())
+        .await;
+}