First version Restate Rust SDK docs

Author: gvdongen

examples/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/my_virtual_object.rs

@@ -0,0 +1,40 @@
+use std::ops::Shl;
+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/my_workflow.rs

@@ -0,0 +1,32 @@
+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;
+}