Struct Request 

pub struct Request<'a, Req, Res = ()> { /* private fields */ }

This struct encapsulates the parameters for a request to a service.

Implementations

impl<'a, Req, Res> Request<'a, Req, Res>

pub fn header(self, key: String, value: String) -> Self

pub fn idempotency_key(self, idempotency_key: impl Into<String>) -> Self

Add idempotency key to the request

pub fn scope(self, scope: impl Into<String>) -> Self

Route this request within the given scope.

A scope is a sub-grouping of resources (invocations, virtual object instances, workflow executions). Under the hood the scope contributes to the partition key, so all resources in a scope get co-located by the restate-server. Idempotency keys are scoped, so the same idempotency key in two different scopes refers to two distinct requests.

pub fn limit_key(self, limit_key: impl Into<String>) -> Self

Add a concurrency limit key to the request.

The limit key enforces hierarchical concurrency limits on invocations sharing the same scope. It can only be used in conjunction with a scope (see Request::scope).

pub fn call(self) -> impl CallFuture<Response = Res> + Send

where Req: Serialize + 'static, Res: Deserialize + 'static,

Call a service. This returns a future encapsulating the response.

pub fn send(self) -> SendHandle

where Req: Serialize + 'static,

Send the request to the service, without waiting for the response.

The request is sent eagerly; you can drop the returned SendHandle to fire-and-forget, or .await it to obtain an InvocationHandle to the newly created invocation.

pub fn send_after(self, delay: Duration) -> SendHandle

where Req: Serialize + 'static,

Schedule the request to the service, without waiting for the response.

Same as Request::send, but the invocation is executed after the given delay.