Add overload to ActivityHandle.getResult with timeout.

Implemented this by adding a Deadline to RootActivityClientInvoker.getActivityResult.
Also:
In tests, use .start(...).get() instead of .executeAsync, for clarity.
Added stopwatch check to testGetActivityResultAsyncTimeoutAbortsPolling to avoid possibility of false negative.

Author: GregoryTravis

temporal-sdk/src/main/java/io/temporal/client/ActivityHandle.java

@@ -4,6 +4,7 @@
 import java.lang.reflect.Type;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import javax.annotation.Nullable;
 
 /**
@@ -27,6 +28,18 @@ public interface ActivityHandle<R> extends UntypedActivityHandle {
    */
   R getResult();
 
+  /**
+   * Blocks until the standalone activity completes and returns the typed result, or throws if the
+   * client-side timeout expires first.
+   *
+   * @param timeout maximum time to wait
+   * @param unit unit of {@code timeout}
+   * @throws ActivityFailedException if the activity failed, timed out on the server, or was
+   *     cancelled
+   * @throws TimeoutException if {@code timeout} expires before the activity completes
+   */
+  R getResult(long timeout, TimeUnit unit) throws TimeoutException;
+
   /**
    * Returns a future that completes when the activity completes and resolves to the typed result.
    */

temporal-sdk/src/main/java/io/temporal/client/ActivityHandleImpl.java

@@ -3,6 +3,7 @@
 import java.lang.reflect.Type;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import javax.annotation.Nullable;
 
 /**
@@ -29,6 +30,22 @@ public R getResult() {
     return delegate.getResult(resultClass, resultType);
   }
 
+  @Override
+  public R getResult(long timeout, TimeUnit unit) throws TimeoutException {
+    return delegate.getResult(timeout, unit, resultClass, resultType);
+  }
+
+  @Override
+  public <T> T getResult(long timeout, TimeUnit unit, Class<T> clazz) throws TimeoutException {
+    return delegate.getResult(timeout, unit, clazz, null);
+  }
+
+  @Override
+  public <T> T getResult(long timeout, TimeUnit unit, Class<T> clazz, @Nullable Type type)
+      throws TimeoutException {
+    return delegate.getResult(timeout, unit, clazz, type);
+  }
+
   @Override
   public CompletableFuture<R> getResultAsync() {
     return delegate.getResultAsync(resultClass, resultType);

temporal-sdk/src/main/java/io/temporal/client/UntypedActivityHandle.java

@@ -51,6 +51,36 @@ public interface UntypedActivityHandle {
    */
   <R> R getResult(Class<R> resultClass, @Nullable Type resultType);
 
+  /**
+   * Blocks until the standalone activity completes and returns the typed result, or throws if the
+   * timeout expires before the activity completes.
+   *
+   * @param timeout maximum time to wait
+   * @param unit unit of {@code timeout}
+   * @param resultClass the class to deserialize the result into
+   * @throws ActivityFailedException if the activity failed, timed out on the server, or was
+   *     cancelled
+   * @throws TimeoutException if the client-side {@code timeout} expires before the activity
+   *     completes
+   */
+  <R> R getResult(long timeout, TimeUnit unit, Class<R> resultClass) throws TimeoutException;
+
+  /**
+   * Blocks until the standalone activity completes and returns the typed result, or throws if the
+   * timeout expires. Use this overload for generic return types (e.g. {@code List<String>}).
+   *
+   * @param timeout maximum time to wait
+   * @param unit unit of {@code timeout}
+   * @param resultClass the class to deserialize the result into
+   * @param resultType the generic type to use for deserialization; may be {@code null}
+   * @throws ActivityFailedException if the activity failed, timed out on the server, or was
+   *     cancelled
+   * @throws TimeoutException if the client-side {@code timeout} expires before the activity
+   *     completes
+   */
+  <R> R getResult(long timeout, TimeUnit unit, Class<R> resultClass, @Nullable Type resultType)
+      throws TimeoutException;
+
   /**
    * Returns a future that completes when the activity completes and resolves to the typed result.
    *

temporal-sdk/src/main/java/io/temporal/common/interceptors/ActivityClientCallsInterceptor.java

@@ -11,6 +11,7 @@
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.stream.Stream;
 import javax.annotation.Nullable;
 
@@ -47,7 +48,8 @@ public interface ActivityClientCallsInterceptor {
    * @return output wrapping the deserialized activity result
    * @throws ActivityFailedException if the activity failed or was cancelled
    */
-  <R> GetActivityResultOutput<R> getActivityResult(GetActivityResultInput<R> input);
+  <R> GetActivityResultOutput<R> getActivityResult(GetActivityResultInput<R> input)
+      throws TimeoutException;
 
   /**
    * Returns the current execution description for a standalone activity. If a long-poll token from
@@ -117,7 +119,7 @@ default <R> CompletableFuture<GetActivityResultOutput<R>> getActivityResultAsync
         () -> {
           try {
             return getActivityResult(input);
-          } catch (ActivityFailedException e) {
+          } catch (ActivityFailedException | TimeoutException e) {
             throw new java.util.concurrent.CompletionException(e);
           }
         });

temporal-sdk/src/main/java/io/temporal/common/interceptors/ActivityClientCallsInterceptorBase.java

@@ -1,6 +1,7 @@
 package io.temporal.common.interceptors;
 
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeoutException;
 
 /** Convenience base class for {@link ActivityClientCallsInterceptor} implementations. */
 public class ActivityClientCallsInterceptorBase implements ActivityClientCallsInterceptor {
@@ -17,7 +18,8 @@ public StartActivityOutput startActivity(StartActivityInput input) {
   }
 
   @Override
-  public <R> GetActivityResultOutput<R> getActivityResult(GetActivityResultInput<R> input) {
+  public <R> GetActivityResultOutput<R> getActivityResult(GetActivityResultInput<R> input)
+      throws TimeoutException {
     return next.getActivityResult(input);
   }
 

temporal-sdk/src/main/java/io/temporal/internal/client/ActivityHandleImpl.java

@@ -6,6 +6,7 @@
 import java.lang.reflect.Type;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicReference;
 import javax.annotation.Nullable;
 
@@ -46,10 +47,32 @@ public <R> R getResult(Class<R> resultClass) {
 
   @Override
   public <R> R getResult(Class<R> resultClass, @Nullable Type resultType) {
+    try {
+      return clientCallsInterceptor
+          .getActivityResult(
+              new ActivityClientCallsInterceptor.GetActivityResultInput<>(
+                  activityId, activityRunId, resultClass, resultType))
+          .getResult();
+    } catch (TimeoutException e) {
+      // unreachable: no-timeout input uses Long.MAX_VALUE deadline
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Override
+  public <R> R getResult(long timeout, TimeUnit unit, Class<R> resultClass)
+      throws TimeoutException {
+    return getResult(timeout, unit, resultClass, null);
+  }
+
+  @Override
+  public <R> R getResult(
+      long timeout, TimeUnit unit, Class<R> resultClass, @Nullable Type resultType)
+      throws TimeoutException {
     return clientCallsInterceptor
         .getActivityResult(
             new ActivityClientCallsInterceptor.GetActivityResultInput<>(
-                activityId, activityRunId, resultClass, resultType))
+                activityId, activityRunId, resultClass, resultType, timeout, unit))
         .getResult();
   }
 

temporal-sdk/src/main/java/io/temporal/internal/client/RootActivityClientInvoker.java

@@ -122,9 +122,11 @@ public StartActivityOutput startActivity(StartActivityInput input) {
   }
 
   @Override
-  public <R> GetActivityResultOutput<R> getActivityResult(GetActivityResultInput<R> input) {
+  public <R> GetActivityResultOutput<R> getActivityResult(GetActivityResultInput<R> input)
+      throws TimeoutException {
     String namespace = clientOptions.getNamespace();
     DataConverter dc = clientOptions.getDataConverter();
+    Deadline deadline = Deadline.after(input.getTimeout(), input.getTimeoutUnit());
 
     while (true) {
       PollActivityExecutionRequest.Builder pollRequest =
@@ -135,7 +137,18 @@ public <R> GetActivityResultOutput<R> getActivityResult(GetActivityResultInput<R
         pollRequest.setRunId(input.getRunId());
       }
 
-      PollActivityExecutionResponse pollResponse = genericClient.pollActivity(pollRequest.build());
+      PollActivityExecutionResponse pollResponse;
+      try {
+        pollResponse = genericClient.pollActivity(pollRequest.build(), deadline);
+      } catch (StatusRuntimeException e) {
+        if (deadline.isExpired() && Status.Code.DEADLINE_EXCEEDED.equals(e.getStatus().getCode())) {
+          throw new TimeoutException(
+              "Activity did not complete within timeout: activityId='"
+                  + input.getActivityId()
+                  + "'");
+        }
+        throw e;
+      }
 
       if (!pollResponse.hasOutcome()) {
         if (Thread.currentThread().isInterrupted()) {

temporal-sdk/src/main/java/io/temporal/internal/client/external/GenericWorkflowClient.java

@@ -78,6 +78,10 @@ ExecuteMultiOperationResponse executeMultiOperation(
   @Experimental
   PollActivityExecutionResponse pollActivity(PollActivityExecutionRequest request);
 
+  @Experimental
+  PollActivityExecutionResponse pollActivity(
+      PollActivityExecutionRequest request, @Nonnull Deadline deadline);
+
   @Experimental
   CompletableFuture<PollActivityExecutionResponse> pollActivityAsync(
       PollActivityExecutionRequest request, @Nonnull Deadline deadline);

temporal-sdk/src/main/java/io/temporal/internal/client/external/GenericWorkflowClientImpl.java

@@ -452,6 +452,20 @@ public PollActivityExecutionResponse pollActivity(PollActivityExecutionRequest r
         new GrpcRetryer.GrpcRetryerOptions(DefaultStubLongPollRpcRetryOptions.INSTANCE, null));
   }
 
+  @Override
+  public PollActivityExecutionResponse pollActivity(
+      PollActivityExecutionRequest request, @Nonnull Deadline deadline) {
+    return grpcRetryer.retryWithResult(
+        () ->
+            service
+                .blockingStub()
+                .withOption(METRICS_TAGS_CALL_OPTIONS_KEY, metricsScope)
+                .withOption(HISTORY_LONG_POLL_CALL_OPTIONS_KEY, true)
+                .withDeadline(deadline)
+                .pollActivityExecution(request),
+        new GrpcRetryer.GrpcRetryerOptions(DefaultStubLongPollRpcRetryOptions.INSTANCE, deadline));
+  }
+
   @Override
   public CompletableFuture<PollActivityExecutionResponse> pollActivityAsync(
       PollActivityExecutionRequest request, @Nonnull Deadline deadline) {

temporal-sdk/src/test/java/io/temporal/client/functional/GetActivityResultAsyncOverServerLongPollWaitTest.java

@@ -68,6 +68,9 @@ private StartActivityOptions slowOpts() {
   @Test(timeout = 2 * ACTIVITY_LONG_POLL_TIMEOUT_SECONDS * 1000)
   public void testGetResultAsync() throws ExecutionException, InterruptedException {
     assumeTrue(SDKTestWorkflowRule.useExternalService);
-    newActivityClient().executeAsync(SlowActivity.class, SlowActivity::run, slowOpts()).get();
+    newActivityClient()
+        .start(SlowActivity.class, SlowActivity::run, slowOpts())
+        .getResultAsync()
+        .get();
   }
 }