pick temporalio/sdk-java#105

Author: Shaddoll

src/main/java/com/uber/cadence/activity/Activity.java

@@ -234,25 +234,25 @@ public final class Activity {
    * for an "external system finished" signal containing the final result.
    */
   public static void doNotCompleteOnReturn() {
-    ActivityInternal.doNotCompleteOnReturn();
+    getExecutionContext().doNotCompleteOnReturn();
   }
 
   /**
    * @return task token that is required to report task completion when manual activity completion
    *     is used.
    */
   public static byte[] getTaskToken() {
-    return ActivityInternal.getTask().getTaskToken();
+    return getExecutionContext().getTaskToken();
   }
 
   /** @return workfow execution that requested the activity execution */
   public static com.uber.cadence.WorkflowExecution getWorkflowExecution() {
-    return ActivityInternal.getTask().getWorkflowExecution();
+    return getExecutionContext().getWorkflowExecution();
   }
 
   /** @return task that caused activity execution */
   public static ActivityTask getTask() {
-    return ActivityInternal.getTask();
+    return getExecutionContext().getInfo();
   }
 
   /**
@@ -265,7 +265,7 @@ public static ActivityTask getTask() {
    *     exception.
    */
   public static <V> void heartbeat(V details) throws ActivityCompletionException {
-    ActivityInternal.recordActivityHeartbeat(details);
+    getExecutionContext().heartbeat(details);
   }
 
   /**
@@ -281,7 +281,7 @@ public static <V> void heartbeat(V details) throws ActivityCompletionException {
    * @param detailsClass type of the heartbeat details
    */
   public static <V> Optional<V> getHeartbeatDetails(Class<V> detailsClass) {
-    return ActivityInternal.getHeartbeatDetails(detailsClass, detailsClass);
+    return getExecutionContext().getHeartbeatDetails(detailsClass);
   }
 
   /**
@@ -291,7 +291,7 @@ public static <V> Optional<V> getHeartbeatDetails(Class<V> detailsClass) {
    * @param detailsType type including generic information of the heartbeat details.
    */
   public static <V> Optional<V> getHeartbeatDetails(Class<V> detailsClass, Type detailsType) {
-    return ActivityInternal.getHeartbeatDetails(detailsClass, detailsType);
+    return getExecutionContext().getHeartbeatDetails(detailsClass, detailsType);
   }
 
   /**
@@ -301,19 +301,19 @@ public static <V> Optional<V> getHeartbeatDetails(Class<V> detailsClass, Type de
    *     hide the service.
    */
   public static IWorkflowService getService() {
-    return ActivityInternal.getService();
+    return getExecutionContext().getService();
   }
 
   public static String getDomain() {
-    return ActivityInternal.getDomain();
+    return getExecutionContext().getDomain();
   }
 
   /**
    * @return the activity execution context for the currently executing activity. This can be used
    *     to access activity task metadata and use manual completion.
    */
-  public static com.uber.cadence.internal.sync.ActivityExecutionContext getExecutionContext() {
-    return ActivityInternal.getContext();
+  public static ActivityExecutionContext getExecutionContext() {
+    return ActivityInternal.getExecutionContext();
   }
 
   /**

src/main/java/com/uber/cadence/activity/ActivityExecutionContext.java

@@ -0,0 +1,111 @@
+/*
+ *  Copyright 2012-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Modifications copyright (C) 2017 Uber Technologies, Inc.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not
+ *  use this file except in compliance with the License. A copy of the License is
+ *  located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ *  or in the "license" file accompanying this file. This file is distributed on
+ *  an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ *  express or implied. See the License for the specific language governing
+ *  permissions and limitations under the License.
+ */
+
+package com.uber.cadence.activity;
+
+import com.uber.cadence.WorkflowExecution;
+import com.uber.cadence.client.ActivityCompletionClient;
+import com.uber.cadence.client.ActivityCompletionException;
+import com.uber.cadence.serviceclient.IWorkflowService;
+import java.lang.reflect.Type;
+import java.util.Optional;
+
+/**
+ * Context object passed to an activity implementation. Use {@link Activity#getExecutionContext()}
+ * from an activity implementation to access.
+ */
+public interface ActivityExecutionContext {
+
+  /** Information about activity invocation and the caller workflow */
+  ActivityTask getInfo();
+
+  /**
+   * Use to notify Cadence service that activity execution is alive.
+   *
+   * @param details In case of activity timeout details are returned as a field of the exception
+   *     thrown.
+   * @throws ActivityCompletionException Indicates that activity cancellation was requested by the
+   *     workflow or any other reason for activity to stop execution. Should be rethrown from
+   *     activity implementation to indicate successful cancellation.
+   */
+  <V> void heartbeat(V details) throws ActivityCompletionException;
+
+  /**
+   * Extracts heartbeat details from the last failed attempt. This is used in combination with retry
+   * options. An activity could be scheduled with an optional {@link
+   * com.uber.cadence.common.RetryOptions} on {@link ActivityOptions}. If an activity failed then
+   * the server would attempt to dispatch another activity task to retry according to the retry
+   * options. If there was heartbeat details reported by the activity from the failed attempt, the
+   * details would be delivered along with the activity task for the retry attempt. The activity
+   * could extract the details by {@link #getHeartbeatDetails(Class)}() and resume from the
+   * progress.
+   *
+   * @param detailsClass type of the heartbeat details
+   */
+  <V> Optional<V> getHeartbeatDetails(Class<V> detailsClass);
+
+  /**
+   * Extracts heartbeat details from the last failed attempt. This is used in combination with retry
+   * options. An activity could be scheduled with an optional {@link
+   * com.uber.cadence.common.RetryOptions} on {@link ActivityOptions}. If an activity failed then
+   * the server would attempt to dispatch another activity task to retry according to the retry
+   * options. If there was heartbeat details reported by the activity from the failed attempt, the
+   * details would be delivered along with the activity task for the retry attempt. The activity
+   * could extract the details by {@link #getHeartbeatDetails(Class)}() and resume from the
+   * progress.
+   *
+   * @param detailsClass type of the heartbeat details
+   * @param detailsType type including generic information of the heartbeat details
+   */
+  <V> Optional<V> getHeartbeatDetails(Class<V> detailsClass, Type detailsType);
+
+  /**
+   * A correlation token that can be used to complete the activity asynchronously through {@link
+   * com.uber.cadence.client.ActivityCompletionClient#complete(byte[], Object)}.
+   */
+  byte[] getTaskToken();
+
+  /**
+   * If this method is called during an activity execution then activity is not going to complete
+   * when its method returns. It is expected to be completed asynchronously using {@link
+   * com.uber.cadence.client.ActivityCompletionClient}.
+   */
+  void doNotCompleteOnReturn();
+
+  boolean isDoNotCompleteOnReturn();
+
+  /**
+   * Use for asynchronous completion within the activity worker process. Calling this method
+   * prevents automatic activity completion on return and returns a client that can be used to
+   * complete the activity asynchronously.
+   */
+  ActivityCompletionClient useLocalManualCompletion();
+
+  boolean isUseLocalManualCompletion();
+
+  /** @return workfow execution that requested the activity execution */
+  WorkflowExecution getWorkflowExecution();
+
+  /**
+   * @return an instance of the Cadence service client that is the same used by the invoked activity
+   *     worker.
+   */
+  IWorkflowService getService();
+
+  /** @return the domain of the activity execution */
+  String getDomain();
+}

src/main/java/com/uber/cadence/internal/sync/ActivityExecutionContext.java

@@ -42,12 +42,12 @@
 import org.slf4j.LoggerFactory;
 
 /**
- * Base implementation of an {@link ActivityExecutionContext}.
+ * Base implementation of an {@link com.uber.cadence.activity.ActivityExecutionContext}.
  *
  * @author fateev, suskin
- * @see ActivityExecutionContext
+ * @see com.uber.cadence.activity.ActivityExecutionContext
  */
-class ActivityExecutionContextImpl implements ActivityExecutionContext {
+class ActivityExecutionContextImpl implements com.uber.cadence.activity.ActivityExecutionContext {
 
   private static final Logger log = LoggerFactory.getLogger(ActivityExecutionContextImpl.class);
   private static final long HEARTBEAT_RETRY_WAIT_MILLIS = 1000;
@@ -91,9 +91,13 @@ class ActivityExecutionContextImpl implements ActivityExecutionContext {
         new ManualActivityCompletionClientFactoryImpl(service, domain, dataConverter, metricsScope);
   }
 
-  /** @see ActivityExecutionContext#recordActivityHeartbeat(Object) */
   @Override
-  public <V> void recordActivityHeartbeat(V details) throws ActivityCompletionException {
+  public ActivityTask getInfo() {
+    return task;
+  }
+
+  @Override
+  public <V> void heartbeat(V details) throws ActivityCompletionException {
     if (heartbeatExecutor.isShutdown()) {
       throw new ActivityWorkerShutdownException(task);
     }
@@ -114,6 +118,11 @@ public <V> void recordActivityHeartbeat(V details) throws ActivityCompletionExce
     }
   }
 
+  @Override
+  public <V> Optional<V> getHeartbeatDetails(Class<V> detailsClass) {
+    return getHeartbeatDetails(detailsClass, detailsClass);
+  }
+
   @Override
   public <V> Optional<V> getHeartbeatDetails(Class<V> detailsClass, Type detailsType) {
     lock.lock();
@@ -234,7 +243,6 @@ public ActivityCompletionClient useLocalManualCompletion() {
   }
 
   /** @see ActivityExecutionContext#getTask() */
-  @Override
   public ActivityTask getTask() {
     return task;
   }

src/main/java/com/uber/cadence/internal/sync/ActivityExecutionContextImpl.java

@@ -17,40 +17,13 @@
 
 package com.uber.cadence.internal.sync;
 
-import com.uber.cadence.activity.ActivityTask;
-import com.uber.cadence.serviceclient.IWorkflowService;
-import java.lang.reflect.Type;
-import java.util.Optional;
+import com.uber.cadence.activity.ActivityExecutionContext;
 
 public final class ActivityInternal {
 
   private ActivityInternal() {}
 
-  public static ActivityExecutionContext getContext() {
+  public static ActivityExecutionContext getExecutionContext() {
     return CurrentActivityExecutionContext.get();
   }
-
-  public static <V> void recordActivityHeartbeat(V details) {
-    getContext().recordActivityHeartbeat(details);
-  }
-
-  public static ActivityTask getTask() {
-    return getContext().getTask();
-  }
-
-  public static String getDomain() {
-    return getContext().getDomain();
-  }
-
-  public static IWorkflowService getService() {
-    return getContext().getService();
-  }
-
-  public static void doNotCompleteOnReturn() {
-    getContext().doNotCompleteOnReturn();
-  }
-
-  public static <V> Optional<V> getHeartbeatDetails(Class<V> detailsClass, Type detailsType) {
-    return getContext().getHeartbeatDetails(detailsClass, detailsType);
-  }
 }

src/main/java/com/uber/cadence/internal/sync/ActivityInternal.java

@@ -17,6 +17,8 @@
 
 package com.uber.cadence.internal.sync;
 
+import com.uber.cadence.activity.ActivityExecutionContext;
+
 /**
  * Thread local store of the context object passed to an activity implementation. Avoid using this
  * class directly.