Rename Awaitable -> DurableFuture (#474)

Author: slinkydeveloper

examples/src/main/java/my/restate/sdk/examples/LoanWorkflow.java

@@ -69,7 +69,7 @@ public String run(WorkflowContext ctx, LoanRequest loanRequest) {
     ctx.set(STATUS, Status.WAITING_HUMAN_APPROVAL);
 
     // 3. Wait human approval
-    boolean approved = ctx.promise(HUMAN_APPROVAL).awaitable().await();
+    boolean approved = ctx.promise(HUMAN_APPROVAL).future().await();
     if (!approved) {
       LOG.info("Not approved");
       ctx.set(STATUS, Status.NOT_APPROVED);

sdk-api-gen/src/main/resources/templates/Client.hbs

@@ -1,7 +1,6 @@
 {{#if originalClassPkg}}package {{originalClassPkg}};{{/if}}
 
-import dev.restate.sdk.Awaitable;
-import dev.restate.sdk.CallAwaitable;
+import dev.restate.sdk.CallDurableFuture;
 import dev.restate.sdk.Context;
 import dev.restate.sdk.types.StateKey;
 import dev.restate.serde.Serde;
@@ -43,7 +42,7 @@ public class {{generatedClassSimpleName}} {
         }
 
         {{#handlers}}
-        public CallAwaitable<{{{boxedOutputFqcn}}}> {{methodName}}({{^inputEmpty}}{{{inputFqcn}}} req{{/inputEmpty}}) {
+        public CallDurableFuture<{{{boxedOutputFqcn}}}> {{methodName}}({{^inputEmpty}}{{{inputFqcn}}} req{{/inputEmpty}}) {
             return this.ctx.call(
                 {{../requestsClass}}.{{methodName}}({{#if ../isKeyed}}this.key{{^inputEmpty}}, {{/inputEmpty}}{{/if}}{{^inputEmpty}}req{{/inputEmpty}})
             );

sdk-api-kotlin-gen/src/main/resources/templates/Client.hbs

@@ -1,7 +1,7 @@
 {{#if originalClassPkg}}package {{originalClassPkg}};{{/if}}
 
 {{#contextClientEnabled}}
-import dev.restate.sdk.kotlin.CallAwaitable
+import dev.restate.sdk.kotlin.CallDurableFuture
 import dev.restate.sdk.kotlin.InvocationHandle
 import dev.restate.sdk.kotlin.Context
 import dev.restate.sdk.kotlin.asSendDelayed
@@ -34,7 +34,7 @@ object {{generatedClassSimpleName}} {
     {{#contextClientEnabled}}
     class ContextClient(private val ctx: Context{{#isKeyed}}, private val key: String{{/isKeyed}}){
         {{#handlers}}
-        suspend fun {{methodName}}({{^inputEmpty}}req: {{{inputFqcn}}}, {{/inputEmpty}}init: dev.restate.common.Request.Builder<{{{boxedInputFqcn}}}, {{{boxedOutputFqcn}}}>.() -> Unit = {}): CallAwaitable<{{{boxedOutputFqcn}}}> {
+        suspend fun {{methodName}}({{^inputEmpty}}req: {{{inputFqcn}}}, {{/inputEmpty}}init: dev.restate.common.Request.Builder<{{{boxedInputFqcn}}}, {{{boxedOutputFqcn}}}>.() -> Unit = {}): CallDurableFuture<{{{boxedOutputFqcn}}}> {
             return this.ctx.call(
                 {{../requestsClass}}.{{methodName}}({{#if ../isKeyed}}this.key, {{/if}}{{^inputEmpty}}req, {{/inputEmpty}}init)
             )

sdk-api-kotlin/src/main/kotlin/dev/restate/sdk/kotlin/ContextImpl.kt

@@ -43,14 +43,14 @@ internal constructor(
   override suspend fun <T : Any> get(key: StateKey<T>): T? =
       resolveSerde<T?>(key.serdeInfo())
           .let { serde ->
-            SingleAwaitableImpl(handlerContext.get(key.name()).await()).simpleMap {
+            SingleDurableFutureImpl(handlerContext.get(key.name()).await()).simpleMap {
               it.getOrNull()?.let { serde.deserialize(it) }
             }
           }
           .await()
 
   override suspend fun stateKeys(): Collection<String> =
-      SingleAwaitableImpl(handlerContext.getKeys().await()).await()
+      SingleDurableFutureImpl(handlerContext.getKeys().await()).await()
 
   override suspend fun <T : Any> set(key: StateKey<T>, value: T) {
     handlerContext.set(key.name(), resolveAndSerialize(key.serdeInfo(), value)).await()
@@ -64,12 +64,12 @@ internal constructor(
     handlerContext.clearAll().await()
   }
 
-  override suspend fun timer(duration: Duration, name: String?): Awaitable<Unit> =
-      SingleAwaitableImpl(handlerContext.timer(duration.toJavaDuration(), name).await()).map {}
+  override suspend fun timer(duration: Duration, name: String?): DurableFuture<Unit> =
+      SingleDurableFutureImpl(handlerContext.timer(duration.toJavaDuration(), name).await()).map {}
 
   override suspend fun <Req : Any?, Res : Any?> call(
       request: Request<Req, Res>
-  ): CallAwaitable<Res> =
+  ): CallDurableFuture<Res> =
       resolveSerde<Res>(request.responseTypeTag()).let { responseSerde ->
         val callHandle =
             handlerContext
@@ -85,7 +85,7 @@ internal constructor(
               CompletableFuture.completedFuture<Res>(responseSerde.deserialize(it))
             }
 
-        return@let CallAwaitableImpl(callAsyncResult, callHandle.invocationIdAsyncResult)
+        return@let CallDurableFutureImpl(callAsyncResult, callHandle.invocationIdAsyncResult)
       }
 
   override suspend fun <Req : Any?, Res : Any?> send(
@@ -122,7 +122,7 @@ internal constructor(
       name: String,
       retryPolicy: RetryPolicy?,
       block: suspend () -> T
-  ): Awaitable<T> {
+  ): DurableFuture<T> {
     var serde: Serde<T> = resolveSerde(typeTag)
     var coroutineCtx = currentCoroutineContext()
     val javaRetryPolicy =
@@ -151,7 +151,7 @@ internal constructor(
               }
             }
             .await()
-    return SingleAwaitableImpl(asyncResult).map { serde.deserialize(it) }
+    return SingleDurableFutureImpl(asyncResult).map { serde.deserialize(it) }
   }
 
   override suspend fun <T : Any> awakeable(typeTag: TypeTag<T>): Awakeable<T> {
@@ -180,13 +180,13 @@ internal constructor(
       DurablePromise<T> {
     val serde: Serde<T> = resolveSerde(key.serdeInfo())
 
-    override suspend fun awaitable(): Awaitable<T> =
-        SingleAwaitableImpl(handlerContext.promise(key.name()).await()).simpleMap {
+    override suspend fun future(): DurableFuture<T> =
+        SingleDurableFutureImpl(handlerContext.promise(key.name()).await()).simpleMap {
           serde.deserialize(it)
         }
 
     override suspend fun peek(): Output<T> =
-        SingleAwaitableImpl(handlerContext.peekPromise(key.name()).await())
+        SingleDurableFutureImpl(handlerContext.peekPromise(key.name()).await())
             .simpleMap { it.map { serde.deserialize(it) } }
             .await()
   }
@@ -196,7 +196,7 @@ internal constructor(
     val serde: Serde<T> = resolveSerde(key.serdeInfo())
 
     override suspend fun resolve(payload: T) {
-      SingleAwaitableImpl(
+      SingleDurableFutureImpl(
               handlerContext
                   .resolvePromise(
                       key.name(), serde.serializeWrappingException(handlerContext, payload))
@@ -205,7 +205,7 @@ internal constructor(
     }
 
     override suspend fun reject(reason: String) {
-      SingleAwaitableImpl(
+      SingleDurableFutureImpl(
               handlerContext.rejectPromise(key.name(), TerminalException(reason)).await())
           .await()
     }