The simplest way to build resilient applications.

@Service
public class RoleUpdateService {

    @Handler
    public void applyRoleUpdate(Context ctx, Update update) {

        boolean success = ctx.run("apply new role", BOOLEAN,
            () -> applyUserRole(update.getUserId(), update.getRole()));

        if (!success) {
            return;
        }

        for (String permission : update.getPermissions()) {
            ctx.run("apply permission",
                () -> applyPermission(update.getUserId(), permission));
        }
    }
}

@Service
public class PaymentService {
  @Handler
  public void processPayment(Context ctx, PaymentRequest request) {
    var webhookFuture = ctx.awakeable(SERDE);
    var payment = ctx.run("Stripe call", SERDE, () -> submitPayment(
            request, Map.of("restate_callback_id", webhookFuture.id())
    ));
    if (payment.getStatus().equals("processing")) {
      // synchronous response inconclusive, await webhook response
      var updatedPayment = webhookFuture.await();
      verifyPayment(updatedPayment);
    } else {
      verifyPayment(payment);
    }
  }
  @Handler
  public void processWebhook(Context ctx) {
    var paymentEvent = verifyAndParseEvent(ctx.request());
    String callbackId = paymentEvent.getMetadata().get("restate_callback_id");
    ctx.awakeableHandle(callbackId).resolve(SERDE, paymentEvent);
  }
}

// --- start payment task ---
server.createContext("/charge", httpExchange -> {
  PaymentRequest req = parsePaymentRequest(httpExchange);
  SendResponse handle = AsyncTaskServiceClient
      .fromIngress(RESTATE_URI)
      .send()
      .processPayment(req, idempotencyKey(req.getPaymentId()));

  respondJson(httpExchange, handle);
});
//  --- connect to payment result ---
server.createContext("/status", httpExchange -> {
  String handle = parseToHandle(httpExchange);
  String response = IngressClient.defaultClient(RESTATE_URI)
      .invocationHandle(handle, STRING)
      .attach();
  respond(httpExchange, response);
});

@VirtualObject
public class EventEnricher {
    static final StateKey USER = StateKey.of("user", of(User.class));
    @Handler
    public void userEvent(ObjectContext ctx, User event) {
        ctx.set(USER, event);
        // time box 100 ms to collect features before emitting result
        EventEnricherClient.fromContext(ctx, ctx.key())
            .send(ofMillis(100)).emit();
    }
    @Handler
    public void featureEvent(ObjectContext ctx, Feature event) {
        User user = ctx.get(USER).orElse(new User());
        user.addFeature(event);
        ctx.set(USER, user);
    }
    @Handler
    public void emit(ObjectContext ctx) {
        send(ctx.key(), ctx.get(USER));
        ctx.clearAll();
    }
}

@Workflow
public class SecretVerifier {

    static final DurablePromiseKey EMAIL_CLICKED =
            DurablePromiseKey.of("email_clicked", JsonSerdes.STRING);

    @Workflow
    public boolean run(WorkflowContext ctx, Email email) {
        String secret = ctx.random().nextUUID().toString();
        ctx.run("send email",
            () -> sendEmailWithLink(email, secret));

        String clickSecret = ctx.promise(EMAIL_CLICKED).awaitable().await();
        return clickSecret.equals(secret);
    }

    @Handler
    public void click(SharedWorkflowContext ctx, String secret) {
        ctx.promiseHandle(EMAIL_CLICKED).resolve(secret);
    }
}

server.createContext("/reserve", httpExchange -> {
      ReservationRequest req = parseRequest(httpExchange.getRequestBody());
      // derive an idempotency key from the parameters
      var idempotencyOps = CallRequestOptions.DEFAULT
          .withIdempotency(req.getReservationId());
      // add idempotency opts to the request to let the service automatically
      // fuse repeated requests
      Reservation reservation = ProductServiceClient
          .fromIngress(RESTATE_RUNTIME_ENDPOINT)
          .reserve(req.getProduct(), idempotencyOps);
      sendResponse(httpExchange, reservation);
    });

@Handler
public void reserveAllProducts(Context ctx, Product[] products) {
    final List reservations = new ArrayList<>();
    try {
        for (Product product : products) {
            Reservation res = ctx.run("Reserve " + product.getId(),
                RESERVE_SERDE, () -> reserve(product)
            );
            reservations.add(res);
        }
    } catch (TerminalException e) {
        reservations.forEach(res -> {
            ctx.run("Undo reservation", () -> cancelReservation(res));
        });
        throw e;
    }
}

@VirtualObject
public class PaymentStateMachine {
  @Handler
  public String makePayment(ObjectContext ctx, PaymentRequest payment) {
    String paymentId = ctx.key();
    switch (ctx.get(STATE_STATUS).orElse(NEW)) {
      case CANCELLED: return paymentId + " was cancelled before";
      case SUCCESS:   return paymentId + " was previously completed";
    }
    wireFunds(payment);
    ctx.set(STATE_STATUS, SUCCESS);
    ctx.set(STATE_PAYMENT_REQUEST, payment);
    return paymentId + " was successfully processed";
  }
  @Handler
  public void cancelPayment(ObjectContext ctx) {
    Status status = ctx.get(STATE_STATUS).orElse(NEW);
    if (status == SUCCESS) {
      PaymentRequest payment = ctx.get(STATE_PAYMENT_REQUEST).get();
      refund(payment);
    }
    ctx.set(STATE_STATUS, CANCELLED);
  }
}