Activity options

temporal-sdk/src/main/java/io/temporal/activity/ActivityOptions.java

@@ -243,6 +243,7 @@ public Builder setVersioningIntent(VersioningIntent versioningIntent) {
       return this;
     }
 
+    /** Merge options with override parameter having higher precedence. */
     public Builder mergeActivityOptions(ActivityOptions override) {
       if (override == null) {
         return this;

temporal-sdk/src/main/java/io/temporal/internal/common/MergedActivityOptions.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2022 Temporal Technologies, Inc. All Rights Reserved.
+ *
+ * Copyright (C) 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 material except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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 io.temporal.internal.common;
+
+import io.temporal.activity.ActivityOptions;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * The chain of ActivityOptions and per type options maps. Used to merge options specified at the
+ * following layers:
+ *
+ * <pre>
+ *     * WorkflowImplementationOptions
+ *     * Workflow
+ *     * ActivityStub
+ * </pre>
+ *
+ * Each next layer overrides specific options specified at the previous layer.
+ */
+public final class MergedActivityOptions {
+
+  /** Common options across all activity types. */
+  private ActivityOptions defaultOptions;
+
+  /** Per activity type options. These override defaultOptions. */
+  private final Map<String, ActivityOptions> optionsMap = new HashMap<>();
+
+  /** The options specified at the previous layer. They are overriden by this object. */
+  private final MergedActivityOptions overridden;
+
+  public MergedActivityOptions(
+      MergedActivityOptions overridden,
+      ActivityOptions defaultOptions,
+      Map<String, ActivityOptions> optionsMap) {
+    this.overridden = overridden;
+    this.defaultOptions = defaultOptions;
+    if (optionsMap != null) {
+      this.optionsMap.putAll(optionsMap);
+    }
+  }
+
+  public MergedActivityOptions(MergedActivityOptions overridden) {
+    this.overridden = overridden;
+    defaultOptions = null;
+  }
+
+  public void setDefaultOptions(ActivityOptions defaultOptions) {
+    this.defaultOptions = defaultOptions;
+  }
+
+  public void applyOptionsMap(Map<String, ActivityOptions> optionsMap) {
+    if (optionsMap != null) {
+      this.optionsMap.putAll(optionsMap);
+    }
+  }
+
+  /** Get merged options for the given activityType. */
+  public ActivityOptions getMergedOptions(String activityType) {
+    ActivityOptions overrideOptions = null;
+    if (overridden != null) {
+      overrideOptions = overridden.getMergedOptions(activityType);
+    }
+    return merge(overrideOptions, defaultOptions, optionsMap.get(activityType));
+  }
+
+  /** later options override the previous ones */
+  private static ActivityOptions merge(ActivityOptions... options) {
+    if (options == null || options.length == 0) {
+      return null;
+    }
+    ActivityOptions result = options[0];
+    for (int i = 1; i < options.length; i++) {
+      if (result == null) {
+        result = options[i];
+      } else {
+        result = result.toBuilder().mergeActivityOptions(options[i]).build();
+      }
+    }
+    return result;
+  }
+}

temporal-sdk/src/main/java/io/temporal/internal/common/MergedLocalActivityOptions.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2022 Temporal Technologies, Inc. All Rights Reserved.
+ *
+ * Copyright (C) 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 material except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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 io.temporal.internal.common;
+
+import io.temporal.activity.LocalActivityOptions;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * The chain of LocalActivityOptions and per type options maps. Used to merge options specified at
+ * the following layers:
+ *
+ * <pre>
+ *     * WorkflowImplementationOptions
+ *     * Workflow
+ *     * ActivityStub
+ * </pre>
+ *
+ * Each next layer overrides specific options specified at the previous layer.
+ */
+public final class MergedLocalActivityOptions {
+
+  /** Common options across all activity types. */
+  private LocalActivityOptions defaultOptions;
+
+  /** Per activity type options. These override defaultOptions. */
+  private final Map<String, LocalActivityOptions> optionsMap = new HashMap<>();
+
+  /** The options specified at the previous layer. They are overriden by this object. */
+  private final MergedLocalActivityOptions overridden;
+
+  public MergedLocalActivityOptions(
+      MergedLocalActivityOptions overridden,
+      LocalActivityOptions defaultOptions,
+      Map<String, LocalActivityOptions> optionsMap) {
+    this.overridden = overridden;
+    this.defaultOptions = defaultOptions;
+    if (optionsMap != null) {
+      this.optionsMap.putAll(optionsMap);
+    }
+  }
+
+  public MergedLocalActivityOptions(MergedLocalActivityOptions overridden) {
+    this.overridden = overridden;
+    defaultOptions = null;
+  }
+
+  public void setDefaultOptions(LocalActivityOptions defaultOptions) {
+    this.defaultOptions = defaultOptions;
+  }
+
+  public void applyOptionsMap(Map<String, LocalActivityOptions> optionsMap) {
+    if (optionsMap != null) {
+      this.optionsMap.putAll(optionsMap);
+    }
+  }
+
+  /** Get merged options for the given activityType. */
+  public LocalActivityOptions getMergedOptions(String activityType) {
+    LocalActivityOptions overrideOptions = null;
+    if (overridden != null) {
+      overrideOptions = overridden.getMergedOptions(activityType);
+    }
+    return merge(overrideOptions, defaultOptions, optionsMap.get(activityType));
+  }
+
+  /** later options override the previous ones */
+  private static LocalActivityOptions merge(LocalActivityOptions... options) {
+    if (options == null || options.length == 0) {
+      return null;
+    }
+    LocalActivityOptions result = options[0];
+    for (int i = 1; i < options.length; i++) {
+      if (result == null) {
+        result = options[i];
+      } else {
+        result = result.toBuilder().mergeActivityOptions(options[i]).build();
+      }
+    }
+    return result;
+  }
+}

temporal-sdk/src/main/java/io/temporal/internal/sync/ActivityInvocationHandler.java

@@ -24,41 +24,36 @@
 import io.temporal.activity.ActivityOptions;
 import io.temporal.common.MethodRetry;
 import io.temporal.common.interceptors.WorkflowOutboundCallsInterceptor;
+import io.temporal.internal.common.MergedActivityOptions;
 import io.temporal.workflow.ActivityStub;
 import io.temporal.workflow.Functions;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
-import java.util.HashMap;
-import java.util.Map;
 import java.util.function.Function;
 
 @VisibleForTesting
 public class ActivityInvocationHandler extends ActivityInvocationHandlerBase {
-  private final ActivityOptions options;
-  private final Map<String, ActivityOptions> activityMethodOptions;
+  private final MergedActivityOptions options;
   private final WorkflowOutboundCallsInterceptor activityExecutor;
   private final Functions.Proc assertReadOnly;
 
   @VisibleForTesting
   public static InvocationHandler newInstance(
       Class<?> activityInterface,
-      ActivityOptions options,
-      Map<String, ActivityOptions> methodOptions,
+      MergedActivityOptions options,
       WorkflowOutboundCallsInterceptor activityExecutor,
       Functions.Proc assertReadOnly) {
     return new ActivityInvocationHandler(
-        activityInterface, activityExecutor, options, methodOptions, assertReadOnly);
+        activityInterface, activityExecutor, options, assertReadOnly);
   }
 
   private ActivityInvocationHandler(
       Class<?> activityInterface,
       WorkflowOutboundCallsInterceptor activityExecutor,
-      ActivityOptions options,
-      Map<String, ActivityOptions> methodOptions,
+      MergedActivityOptions options,
       Functions.Proc assertReadOnly) {
     super(activityInterface);
     this.options = options;
-    this.activityMethodOptions = (methodOptions == null) ? new HashMap<>() : methodOptions;
     this.activityExecutor = activityExecutor;
     this.assertReadOnly = assertReadOnly;
   }
@@ -67,11 +62,7 @@ private ActivityInvocationHandler(
   protected Function<Object[], Object> getActivityFunc(
       Method method, MethodRetry methodRetry, String activityName) {
     Function<Object[], Object> function;
-    ActivityOptions merged =
-        ActivityOptions.newBuilder(options)
-            .mergeActivityOptions(this.activityMethodOptions.get(activityName))
-            .mergeMethodRetry(methodRetry)
-            .build();
+    ActivityOptions merged = options.getMergedOptions(activityName);
     if (merged.getStartToCloseTimeout() == null && merged.getScheduleToCloseTimeout() == null) {
       throw new IllegalArgumentException(
           "Both StartToCloseTimeout and ScheduleToCloseTimeout aren't specified for "

temporal-sdk/src/main/java/io/temporal/internal/sync/LocalActivityInvocationHandler.java

@@ -24,41 +24,36 @@
 import io.temporal.activity.LocalActivityOptions;
 import io.temporal.common.MethodRetry;
 import io.temporal.common.interceptors.WorkflowOutboundCallsInterceptor;
+import io.temporal.internal.common.MergedLocalActivityOptions;
 import io.temporal.workflow.ActivityStub;
 import io.temporal.workflow.Functions;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
-import java.util.HashMap;
-import java.util.Map;
 import java.util.function.Function;
 
 @VisibleForTesting
 public class LocalActivityInvocationHandler extends ActivityInvocationHandlerBase {
-  private final LocalActivityOptions options;
-  private final Map<String, LocalActivityOptions> activityMethodOptions;
+  private final MergedLocalActivityOptions options;
   private final WorkflowOutboundCallsInterceptor activityExecutor;
   private final Functions.Proc assertReadOnly;
 
   @VisibleForTesting
   public static InvocationHandler newInstance(
       Class<?> activityInterface,
-      LocalActivityOptions options,
-      Map<String, LocalActivityOptions> methodOptions,
+      MergedLocalActivityOptions options,
       WorkflowOutboundCallsInterceptor activityExecutor,
       Functions.Proc assertReadOnly) {
     return new LocalActivityInvocationHandler(
-        activityInterface, activityExecutor, options, methodOptions, assertReadOnly);
+        activityInterface, activityExecutor, options, assertReadOnly);
   }
 
   private LocalActivityInvocationHandler(
       Class<?> activityInterface,
       WorkflowOutboundCallsInterceptor activityExecutor,
-      LocalActivityOptions options,
-      Map<String, LocalActivityOptions> methodOptions,
+      MergedLocalActivityOptions options,
       Functions.Proc assertReadOnly) {
     super(activityInterface);
     this.options = options;
-    this.activityMethodOptions = (methodOptions == null) ? new HashMap<>() : methodOptions;
     this.activityExecutor = activityExecutor;
     this.assertReadOnly = assertReadOnly;
   }
@@ -68,11 +63,7 @@ private LocalActivityInvocationHandler(
   public Function<Object[], Object> getActivityFunc(
       Method method, MethodRetry methodRetry, String activityName) {
     Function<Object[], Object> function;
-    LocalActivityOptions mergedOptions =
-        LocalActivityOptions.newBuilder(options)
-            .mergeActivityOptions(activityMethodOptions.get(activityName))
-            .setMethodRetry(methodRetry)
-            .build();
+    LocalActivityOptions mergedOptions = options.getMergedOptions(activityName);
     ActivityStub stub =
         LocalActivityStubImpl.newInstance(mergedOptions, activityExecutor, assertReadOnly);
     function =