A basic subscription service orchestration looks like this:
## Durable Execution
Restate uses Durable Execution to ensure your orchestration logic survives failures and restarts.
Whenever a handler executes an action with the Restate `Context`, this gets send over to the Restate Server and persisted in a log.
On a failure or a crash, the Restate Server sends a retry request that contains the log of the actions that were executed so far.
The service then replays the log to restore state and continues executing the remaining actions.
This process continues until the handler runs till completion.
**Key Benefits:**
* Context `run` actions make external calls or non-deterministic operations durable. They get replayed on failures.
* If the service crashes after payment creation, it resumes at the subscription step
* Deterministic IDs logged with the context ensure operations are idempotent
* Full execution traces for debugging and monitoring
To fix the problem, remove the line `failOnNetflix` from the `createSubscription` function in the `utils.ts` file:
```ts {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/examples/refs/heads/main/typescript/tutorials/tour-of-orchestration-typescript/src/utils.ts#subscription"} theme={null}
export function createSubscription(
userId: string,
subscription: string,
_paymentRef: string,
): string {
failOnNetflix(subscription);
terminalErrorOnDisney(subscription);
console.log(`>>> Created subscription ${subscription} for user ${userId}`);
return "SUCCESS";
}
```
To fix the problem, remove the line `failOnNetflix` from the `createSubscription` function in the `auxiliary/clients/SubscriptionClient.java` file:
```java {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/examples/refs/heads/main/java/tutorials/tour-of-orchestration-java/src/main/java/my/example/auxiliary/clients/SubscriptionClient.java#subscription"} theme={null}
public static String createSubscription(String userId, String subscription, String paymentRef) {
failOnNetflix(subscription);
terminalErrorOnDisney(subscription);
System.out.println(">>> Created subscription " + subscription + " for user " + userId);
return "SUCCESS";
}
```
To fix the problem, remove the line `failOnNetflix` from the `CreateSubscription` function in the `utils.go` file:
```go {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/examples/refs/heads/main/go/tutorials/tour-of-orchestration-go/examples/utils.go#subscription"} theme={null}
func CreateSubscription(userId, subscription, paymentRef string) (string, error) {
if err := failOnNetflix(subscription); err != nil {
return "", err
}
if err := terminalErrorOnDisney(subscription); err != nil {
return "", err
}
fmt.Printf(">>> Created subscription %s for user %s\n", subscription, userId)
return "SUCCESS", nil
}
```
To fix the problem, remove the line `fail_on_netflix` from the `create_subscription` function in the `utils.py` file:
```python {"CODE_LOAD::https://raw.githubusercontent.com/restatedev/examples/refs/heads/main/python/tutorials/tour-of-orchestration-python/app/utils.py#subscription"} theme={null}
def create_subscription(user_id: str, subscription: str, payment_ref: str) -> str:
fail_on_netflix(subscription)
terminal_error_on_disney(subscription)
print(f">>> Created subscription {subscription} for user {user_id}")
return "SUCCESS"
```
* **Built-in concurrency control**: Restate’s Virtual Objects have built-in queuing and consistency guarantees per object key. Handlers either have read-write access (`ObjectContext`) or read-only access (shared object context).
* Only one handler with write access can run at a time per object key to prevent concurrent/lost writes or race conditions.
* Handlers with read-only access can run concurrently to the write-access handlers.
