no_run for code snippets

Author: gvdongen

src/context/mod.rs

@@ -221,7 +221,7 @@ impl<'ctx> WorkflowContext<'ctx> {
 /// ## Durable sleep
 /// To sleep in a Restate application for ten seconds, do the following:
 ///
-/// ```
+/// ```rust,no_run
 /// # use restate_sdk::prelude::*;
 /// # use std::convert::Infallible;
 /// # use std::time::Duration;
@@ -266,7 +266,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextTimers<'ctx> for CTX {}
 ///
 /// You can do request-response calls to Services, Virtual Objects, and Workflows, in the following way:
 ///
-/// ```
+/// ```rust,no_run
 /// # #[path = "../../examples/services"]
 /// # mod services;
 /// # use services::my_service::MyServiceClient;
@@ -329,7 +329,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextTimers<'ctx> for CTX {}
 ///
 /// Handlers can send messages (a.k.a. one-way calls, or fire-and-forget calls), as follows:
 ///
-/// ```
+/// ```rust,no_run
 /// # #[path = "../../examples/services"]
 /// # mod services;
 /// # use services::my_service::MyServiceClient;
@@ -369,7 +369,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextTimers<'ctx> for CTX {}
 ///
 /// To schedule a delayed call, send a message with a delay parameter, as follows:
 ///
-/// ```
+/// ```rust,no_run
 /// # #[path = "../examples/services"]
 /// # mod services;
 /// # use services::my_service::MyServiceClient;
@@ -409,7 +409,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextTimers<'ctx> for CTX {}
 /// Invocations will execute in the same order in which they arrive at Restate.
 /// For example, assume a handler calls the same Virtual Object twice:
 ///
-/// ```
+/// ```rust,no_run
 /// # #[path = "../../examples/services"]
 /// # mod services;
 /// # use services::my_virtual_object::MyVirtualObjectClient;
@@ -563,7 +563,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextClient<'ctx> for CTX {}
 /// 3. **Wait** until the other process has executed the task.
 ///    The handler **receives the payload and resumes**.
 ///
-/// ```
+/// ```rust,no_run
 /// # use restate_sdk::prelude::*;
 /// #
 /// # async fn handle(ctx: Context<'_>) -> Result<(), HandlerError> {
@@ -605,7 +605,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextClient<'ctx> for CTX {}
 ///
 /// - Resolving via the SDK with its ID and an optional payload, or rejecting with its ID and a reason:
 ///
-/// ```
+/// ```rust,no_run
 /// # use restate_sdk::prelude::*;
 /// #
 /// # async fn handle(ctx: Context<'_>, id: String) -> Result<(), HandlerError> {
@@ -661,7 +661,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextAwakeables<'ctx> for CTX {}
 /// Restate replays the result instead of re-executing the operation on retries.
 ///
 /// Here is an example of a database request for which the string response is stored in Restate:
-/// ```
+/// ```rust,no_run
 /// # use restate_sdk::prelude::*;
 /// # async fn handle(ctx: Context<'_>) -> Result<(), HandlerError> {
 /// let response = ctx.run(|| do_db_request()).await?;
@@ -692,7 +692,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextAwakeables<'ctx> for CTX {}
 ///
 /// Do not use this in cryptographic contexts.
 ///
-/// ```
+/// ```rust,no_run
 /// # use restate_sdk::prelude::*;
 /// # use uuid::Uuid;
 /// # async fn uuid_generate(mut ctx: Context<'_>) {
@@ -706,7 +706,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextAwakeables<'ctx> for CTX {}
 /// This returns a new pseudorandom float within the range `[0,1]`.
 /// This is the equivalent of JS `Math.random()` but deterministically replayable.
 ///
-/// ```
+/// ```rust,no_run
 /// # use restate_sdk::prelude::*;
 /// # use rand::Rng;
 /// async fn rand_generate(mut ctx: Context<'_>) {
@@ -766,7 +766,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextSideEffects<'ctx> for CTX {
 /// **Info: Serializing state**:
 /// You can store any type of value that that implements the `serde::Serialize` and `serde::Deserialize` traits ([see serialization docs][crate::serde]).
 ///
-/// ```
+/// ```rust,no_run
 /// # use restate_sdk::prelude::*;
 /// #
 /// # async fn my_handler(ctx: ObjectContext<'_>) -> Result<(), HandlerError> {
@@ -829,7 +829,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx> + private::SealedCanReadState> Cont
 /// **Info: Serializing state**:
 /// You can store any type of value that that implements the `serde::Serialize` and `serde::Deserialize` traits ([see serialization docs][crate::serde]).
 ///
-/// ```
+/// ```rust,no_run
 /// # use restate_sdk::prelude::*;
 /// #
 /// # async fn my_handler(ctx: ObjectContext<'_>) -> Result<(), HandlerError> {

src/errors.rs

@@ -8,7 +8,7 @@
 //!
 //! You can throw a terminal exception with an optional HTTP status code and a message anywhere in your handler, as follows:
 //!
-//! ```
+//! ```rust,no_run
 //! # use restate_sdk::prelude::*;
 //! # async fn handle() -> Result<(), HandlerError> {
 //! Err(TerminalError::new("This is a terminal error").into())

src/http_server.rs

@@ -6,7 +6,7 @@
 //! 2. Bind one or multiple services to it.
 //! 3. Listen on the specified port (default `9080`) for connections and requests.
 //!
-//! ```
+//! ```rust,no_run
 //! # #[path = "../examples/services"]
 //! # mod services;
 //! # use services::my_service::{MyService, MyServiceImpl};
@@ -37,7 +37,7 @@
 //! instance. You can find out more about request identity in the [Security docs](https://docs.restate.dev/operate/security#locking-down-service-access).
 //! Add the identity key to your endpoint as follows:
 //!
-//! ```
+//! ```rust,no_run
 //! # #[path = "../examples/services"]
 //! # mod services;
 //! # use services::my_service::{MyService, MyServiceImpl};

src/lib.rs

@@ -358,7 +358,7 @@ pub use restate_sdk_macros::object;
 /// ## Implementing workflows
 /// Have a look at the code example to get a better understanding of how workflows are implemented:
 ///
-/// ```
+/// ```rust,no_run
 /// use restate_sdk::prelude::*;
 ///
 /// #[restate_sdk::workflow]
@@ -376,7 +376,7 @@ pub use restate_sdk_macros::object;
 ///     async fn run(&self, mut ctx: WorkflowContext<'_>, email: String) -> Result<bool, HandlerError> {
 ///
 ///         let secret = ctx.rand_uuid().to_string();
-///         ctx.run(|| send_email_with_link(email, secret)).await?;
+///         ctx.run(|| send_email_with_link(email.clone(), secret.clone())).await?;
 ///         ctx.set("status", "Email sent".to_string());
 ///
 ///         let click_secret = ctx.promise::<String>("email.clicked").await?;