Linting (#780)

Author: abhishekj720

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

@@ -163,18 +163,19 @@
  *     }
  * </code></pre>
  *
- * <p>Caution: since using this sometimes implies "long" timeouts, activity-worker losses prior to recording the
- * {@link Activity#getTaskToken()} in an external system (or prior to another thread calling it) may not be noticed
- * until the "long" timeout occurs. This can be resolved by having another system call
- * {@link com.uber.cadence.client.ActivityCompletionClient#heartbeat(byte[], Object)} while that external action is
- * running, but there is currently no way to mitigate this issue without these heartbeats.  For in-process-only async
- * completion, relying on heartbeating is safe and reliable because these heartbeats should occur as long as the
- * process / background thread is still running.
- *
- * <p>If you cannot heartbeat and cannot tolerate this kind of delayed-activity-loss detection, consider emulating a
- * long activity via a signal channel instead: you can start a short-lived activity and wait for a "saved to external
- * system" signal, retrying as necessary, and then wait for an "external system finished" signal containing the final
- * result.
+ * <p>Caution: since using this sometimes implies "long" timeouts, activity-worker losses prior to
+ * recording the {@link Activity#getTaskToken()} in an external system (or prior to another thread
+ * calling it) may not be noticed until the "long" timeout occurs. This can be resolved by having
+ * another system call {@link com.uber.cadence.client.ActivityCompletionClient#heartbeat(byte[],
+ * Object)} while that external action is running, but there is currently no way to mitigate this
+ * issue without these heartbeats. For in-process-only async completion, relying on heartbeating is
+ * safe and reliable because these heartbeats should occur as long as the process / background
+ * thread is still running.
+ *
+ * <p>If you cannot heartbeat and cannot tolerate this kind of delayed-activity-loss detection,
+ * consider emulating a long activity via a signal channel instead: you can start a short-lived
+ * activity and wait for a "saved to external system" signal, retrying as necessary, and then wait
+ * for an "external system finished" signal containing the final result.
  *
  * <h3>Activity Heartbeating</h3>
  *
@@ -214,23 +215,23 @@
 public final class Activity {
 
   /**
-   * If this method is called during an activity execution then activity will not complete
-   * when its method returns. It is expected to be completed asynchronously using {@link
+   * If this method is called during an activity execution then activity will not complete when its
+   * method returns. It is expected to be completed asynchronously using {@link
    * com.uber.cadence.client.ActivityCompletionClient}.
    *
-   * <p>Caution: since using this sometimes implies "long" timeouts, activity-worker losses prior to recording the
-   * {@link Activity#getTaskToken()} in an external system (or prior to another thread calling it) may not be noticed
-   * until the "long" timeout occurs.
-   * This can be resolved by having another system call
-   * {@link com.uber.cadence.client.ActivityCompletionClient#heartbeat(byte[], Object)} while that external action is
-   * running, but there is currently no way to mitigate this issue without these heartbeats.  For in-process-only async
-   * completion, relying on heartbeating is safe and reliable because these heartbeats should occur as long as the
-   * process / background thread is still running.
+   * <p>Caution: since using this sometimes implies "long" timeouts, activity-worker losses prior to
+   * recording the {@link Activity#getTaskToken()} in an external system (or prior to another thread
+   * calling it) may not be noticed until the "long" timeout occurs. This can be resolved by having
+   * another system call {@link com.uber.cadence.client.ActivityCompletionClient#heartbeat(byte[],
+   * Object)} while that external action is running, but there is currently no way to mitigate this
+   * issue without these heartbeats. For in-process-only async completion, relying on heartbeating
+   * is safe and reliable because these heartbeats should occur as long as the process / background
+   * thread is still running.
    *
-   * <p>If you cannot heartbeat and cannot tolerate this kind of delayed-activity-loss detection, consider emulating a
-   * long activity via a signal channel instead: you can start a short-lived activity and wait for a "saved to external
-   * system" signal, retrying as necessary, and then wait for an "external system finished" signal containing the final
-   * result.
+   * <p>If you cannot heartbeat and cannot tolerate this kind of delayed-activity-loss detection,
+   * consider emulating a long activity via a signal channel instead: you can start a short-lived
+   * activity and wait for a "saved to external system" signal, retrying as necessary, and then wait
+   * for an "external system finished" signal containing the final result.
    */
   public static void doNotCompleteOnReturn() {
     ActivityInternal.doNotCompleteOnReturn();

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

@@ -66,7 +66,8 @@ protected Function<Object[], Object> getActivityFunc(
     if (activityOptionsOverride == null) {
       stub = ActivityStubImpl.newInstance(mergedOptions, activityExecutor);
     } else {
-      ActivityOptions mergedOverrideOptions = ActivityOptions.merge(activityMethod, methodRetry, activityOptionsOverride);
+      ActivityOptions mergedOverrideOptions =
+          ActivityOptions.merge(activityMethod, methodRetry, activityOptionsOverride);
       stub = ActivityStubImpl.newInstance(mergedOverrideOptions, activityExecutor);
     }
 

src/main/java/com/uber/cadence/internal/worker/ActivityPollTask.java

@@ -17,6 +17,9 @@
 
 package com.uber.cadence.internal.worker;
 
+import static com.uber.cadence.internal.metrics.MetricsTagValue.INTERNAL_SERVICE_ERROR;
+import static com.uber.cadence.internal.metrics.MetricsTagValue.SERVICE_BUSY;
+
 import com.google.common.collect.ImmutableMap;
 import com.uber.cadence.InternalServiceError;
 import com.uber.cadence.PollForActivityTaskRequest;
@@ -32,9 +35,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import static com.uber.cadence.internal.metrics.MetricsTagValue.INTERNAL_SERVICE_ERROR;
-import static com.uber.cadence.internal.metrics.MetricsTagValue.SERVICE_BUSY;
-
 final class ActivityPollTask extends ActivityPollTaskBase {
 
   private static final Logger log = LoggerFactory.getLogger(ActivityPollTask.class);
@@ -72,17 +72,20 @@ protected PollForActivityTaskResponse pollTask() throws TException {
     try {
       result = service.PollForActivityTask(pollRequest);
     } catch (InternalServiceError e) {
-      options.getMetricsScope()
-              .tagged(ImmutableMap.of(MetricsTag.CAUSE, INTERNAL_SERVICE_ERROR))
-              .counter(MetricsType.ACTIVITY_POLL_TRANSIENT_FAILED_COUNTER).inc(1);
+      options
+          .getMetricsScope()
+          .tagged(ImmutableMap.of(MetricsTag.CAUSE, INTERNAL_SERVICE_ERROR))
+          .counter(MetricsType.ACTIVITY_POLL_TRANSIENT_FAILED_COUNTER)
+          .inc(1);
       throw e;
     } catch (ServiceBusyError e) {
-      options.getMetricsScope()
-              .tagged(ImmutableMap.of(MetricsTag.CAUSE, SERVICE_BUSY))
-              .counter(MetricsType.ACTIVITY_POLL_TRANSIENT_FAILED_COUNTER).inc(1);
+      options
+          .getMetricsScope()
+          .tagged(ImmutableMap.of(MetricsTag.CAUSE, SERVICE_BUSY))
+          .counter(MetricsType.ACTIVITY_POLL_TRANSIENT_FAILED_COUNTER)
+          .inc(1);
       throw e;
-    }
-    catch (TException e) {
+    } catch (TException e) {
       options.getMetricsScope().counter(MetricsType.ACTIVITY_POLL_FAILED_COUNTER).inc(1);
       throw e;
     }

src/main/java/com/uber/cadence/internal/worker/WorkflowPollTask.java

@@ -17,6 +17,9 @@
 
 package com.uber.cadence.internal.worker;
 
+import static com.uber.cadence.internal.metrics.MetricsTagValue.INTERNAL_SERVICE_ERROR;
+import static com.uber.cadence.internal.metrics.MetricsTagValue.SERVICE_BUSY;
+
 import com.uber.cadence.InternalServiceError;
 import com.uber.cadence.PollForDecisionTaskRequest;
 import com.uber.cadence.PollForDecisionTaskResponse;
@@ -30,15 +33,11 @@
 import com.uber.m3.tally.Stopwatch;
 import com.uber.m3.util.Duration;
 import com.uber.m3.util.ImmutableMap;
-
 import java.util.Objects;
 import org.apache.thrift.TException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import static com.uber.cadence.internal.metrics.MetricsTagValue.INTERNAL_SERVICE_ERROR;
-import static com.uber.cadence.internal.metrics.MetricsTagValue.SERVICE_BUSY;
-
 final class WorkflowPollTask implements Poller.PollTask<PollForDecisionTaskResponse> {
 
   private static final Logger log = LoggerFactory.getLogger(WorkflowWorker.class);
@@ -83,13 +82,15 @@ public PollForDecisionTaskResponse poll() throws TException {
       result = service.PollForDecisionTask(pollRequest);
     } catch (InternalServiceError e) {
       metricScope
-              .tagged(ImmutableMap.of(MetricsTag.CAUSE, INTERNAL_SERVICE_ERROR))
-              .counter(MetricsType.DECISION_POLL_TRANSIENT_FAILED_COUNTER).inc(1);
+          .tagged(ImmutableMap.of(MetricsTag.CAUSE, INTERNAL_SERVICE_ERROR))
+          .counter(MetricsType.DECISION_POLL_TRANSIENT_FAILED_COUNTER)
+          .inc(1);
       throw e;
     } catch (ServiceBusyError e) {
       metricScope
-              .tagged(ImmutableMap.of(MetricsTag.CAUSE, SERVICE_BUSY))
-              .counter(MetricsType.DECISION_POLL_TRANSIENT_FAILED_COUNTER).inc(1);
+          .tagged(ImmutableMap.of(MetricsTag.CAUSE, SERVICE_BUSY))
+          .counter(MetricsType.DECISION_POLL_TRANSIENT_FAILED_COUNTER)
+          .inc(1);
       throw e;
     } catch (TException e) {
       metricScope.counter(MetricsType.DECISION_POLL_FAILED_COUNTER).inc(1);

src/main/java/com/uber/cadence/worker/WorkflowImplementationOptions.java

@@ -46,16 +46,19 @@ public Builder setNonDeterministicWorkflowPolicy(
     /**
      * Set overrides for a specific workflow implementation for activity options.
      *
-     * @param activityOptionOverrides a map where the key is the activity name and the value is the activity
-     *     options that should override existing activity configuration that comes from @ActivityMethod annotation.
+     * @param activityOptionOverrides a map where the key is the activity name and the value is the
+     *     activity options that should override existing activity configuration that comes
+     *     from @ActivityMethod annotation.
      */
-    public Builder setActivityOptionOverrides(Map<String, ActivityOptions> activityOptionOverrides) {
+    public Builder setActivityOptionOverrides(
+        Map<String, ActivityOptions> activityOptionOverrides) {
       this.activityOptionOverrides = activityOptionOverrides;
       return this;
     }
 
     public WorkflowImplementationOptions build() {
-      return new WorkflowImplementationOptions(nonDeterministicWorkflowPolicy, activityOptionOverrides);
+      return new WorkflowImplementationOptions(
+          nonDeterministicWorkflowPolicy, activityOptionOverrides);
     }
   }
 

src/test/java/com/uber/cadence/workflow/WorkflowTest.java

@@ -6339,7 +6339,9 @@ public void testActivityDoesntTimeoutWhenTimeoutsAreLonger() throws Exception {
             .build());
 
     startWorkerFor(
-        new WorkflowImplementationOptions.Builder().setActivityOptionOverrides(activityOptionsMap).build(),
+        new WorkflowImplementationOptions.Builder()
+            .setActivityOptionOverrides(activityOptionsMap)
+            .build(),
         TestWorkflowActivityOptionOverride.class);
 
     TestWorkflow1 workflowStub =