Added support for calling polymorphic activities

Author: mfateev

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

@@ -30,13 +30,15 @@ class ActivityInvocationHandler extends ActivityInvocationHandlerBase {
   private final WorkflowInterceptor activityExecutor;
 
   static InvocationHandler newInstance(
-      ActivityOptions options, WorkflowInterceptor activityExecutor) {
-    return new ActivityInvocationHandler(options, activityExecutor);
+      Class<?> activityInterface, ActivityOptions options, WorkflowInterceptor activityExecutor) {
+    return new ActivityInvocationHandler(activityInterface, activityExecutor, options);
   }
 
-  private ActivityInvocationHandler(ActivityOptions options, WorkflowInterceptor activityExecutor) {
+  private ActivityInvocationHandler(
+      Class<?> activityInterface, WorkflowInterceptor activityExecutor, ActivityOptions options) {
     this.options = options;
     this.activityExecutor = activityExecutor;
+    init(activityInterface);
   }
 
   @Override

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

@@ -18,17 +18,19 @@
 package com.uber.cadence.internal.sync;
 
 import static com.uber.cadence.internal.common.InternalUtils.getValueOrDefault;
+import static com.uber.cadence.internal.sync.POJOActivityTaskHandler.getAnnotatedInterfaceMethodsFromInterface;
 
+import com.uber.cadence.activity.ActivityInterface;
 import com.uber.cadence.activity.ActivityMethod;
 import com.uber.cadence.common.MethodRetry;
 import com.uber.cadence.internal.common.InternalUtils;
 import com.uber.cadence.internal.sync.AsyncInternal.AsyncMarker;
-import com.uber.cadence.workflow.Workflow;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Set;
 import java.util.function.Function;
 
 /** Dynamic implementation of a strongly typed child workflow interface. */
@@ -45,33 +47,35 @@ static <T> T newProxy(Class<T> activityInterface, InvocationHandler invocationHa
             invocationHandler);
   }
 
+  protected void init(Class<?> activityInterface) {
+    Set<POJOActivityTaskHandler.MethodInterfacePair> activityMethods =
+        getAnnotatedInterfaceMethodsFromInterface(activityInterface, ActivityInterface.class);
+    if (activityMethods.isEmpty()) {
+      throw new IllegalArgumentException(
+          "Class doesn't implement any non empty interface annotated with @ActivityInterface: "
+              + activityInterface.getName());
+    }
+    for (POJOActivityTaskHandler.MethodInterfacePair pair : activityMethods) {
+      Method method = pair.getMethod();
+      ActivityMethod activityMethod = method.getAnnotation(ActivityMethod.class);
+      String activityType;
+      if (activityMethod != null && !activityMethod.name().isEmpty()) {
+        activityType = activityMethod.name();
+      } else {
+        activityType = InternalUtils.getSimpleName(pair.getType(), method);
+      }
+
+      MethodRetry methodRetry = method.getAnnotation(MethodRetry.class);
+      Function<Object[], Object> function = getActivityFunc(method, methodRetry, activityType);
+      methodFunctions.put(method, function);
+    }
+  }
+
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) {
     Function<Object[], Object> function = methodFunctions.get(method);
     if (function == null) {
-      try {
-        if (method.equals(Object.class.getMethod("toString"))) {
-          // TODO: activity info
-          return "ActivityInvocationHandlerBase";
-        }
-        if (!method.getDeclaringClass().isInterface()) {
-          throw new IllegalArgumentException(
-              "Interface type is expected: " + method.getDeclaringClass());
-        }
-        MethodRetry methodRetry = method.getAnnotation(MethodRetry.class);
-        ActivityMethod activityMethod = method.getAnnotation(ActivityMethod.class);
-        String activityName;
-        if (activityMethod == null || activityMethod.name().isEmpty()) {
-          activityName = InternalUtils.getSimpleName(method);
-        } else {
-          activityName = activityMethod.name();
-        }
-
-        function = getActivityFunc(method, methodRetry, activityName);
-        methodFunctions.put(method, function);
-      } catch (NoSuchMethodException e) {
-        throw Workflow.wrap(e);
-      }
+      throw new IllegalArgumentException("Unexpected method: " + method);
     }
     return getValueOrDefault(function.apply(args), method.getReturnType());
   }

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

@@ -30,14 +30,19 @@ class LocalActivityInvocationHandler extends ActivityInvocationHandlerBase {
   private final WorkflowInterceptor activityExecutor;
 
   static InvocationHandler newInstance(
-      LocalActivityOptions options, WorkflowInterceptor activityExecutor) {
-    return new LocalActivityInvocationHandler(options, activityExecutor);
+      Class<?> activityInterface,
+      LocalActivityOptions options,
+      WorkflowInterceptor activityExecutor) {
+    return new LocalActivityInvocationHandler(activityInterface, activityExecutor, options);
   }
 
   private LocalActivityInvocationHandler(
-      LocalActivityOptions options, WorkflowInterceptor activityExecutor) {
+      Class<?> activityInterface,
+      WorkflowInterceptor activityExecutor,
+      LocalActivityOptions options) {
     this.options = options;
     this.activityExecutor = activityExecutor;
+    init(activityInterface);
   }
 
   @Override

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

@@ -88,7 +88,7 @@ private void addActivityImplementation(
       }
     }
     Set<MethodInterfacePair> activityMethods =
-        getAnnotatedInterfaceMethods(cls, ActivityInterface.class);
+        getAnnotatedInterfaceMethodsFromImplementation(cls, ActivityInterface.class);
     if (activityMethods.isEmpty()) {
       throw new IllegalArgumentException(
           "Class doesn't implement any non empty interface annotated with @ActivityInterface: "
@@ -338,7 +338,7 @@ public int hashCode() {
     }
   }
 
-  Set<MethodInterfacePair> getAnnotatedInterfaceMethods(
+  static Set<MethodInterfacePair> getAnnotatedInterfaceMethodsFromImplementation(
       Class<?> implementationClass, Class<? extends Annotation> annotationClass) {
     if (implementationClass.isInterface()) {
       throw new IllegalArgumentException(
@@ -347,11 +347,33 @@ Set<MethodInterfacePair> getAnnotatedInterfaceMethods(
     Set<MethodInterfacePair> pairs = new HashSet<>();
     // Methods inherited from interfaces that are not annotated with @ActivityInterface
     Set<MethodWrapper> ignored = new HashSet<>();
-    getAnnotatedInterfaceMethods(implementationClass, annotationClass, ignored, pairs);
+    getAnnotatedInterfaceMethodsFromImplementation(
+        implementationClass, annotationClass, ignored, pairs);
     return pairs;
   }
 
-  private void getAnnotatedInterfaceMethods(
+  static Set<MethodInterfacePair> getAnnotatedInterfaceMethodsFromInterface(
+      Class<?> iClass, Class<? extends Annotation> annotationClass) {
+    if (!iClass.isInterface()) {
+      throw new IllegalArgumentException("Interface expected. Found: " + iClass.getSimpleName());
+    }
+    Annotation annotation = iClass.getAnnotation(annotationClass);
+    if (annotation == null) {
+      throw new IllegalArgumentException(
+          "@ActivityInterface annotation is required on the stub interface: "
+              + iClass.getSimpleName());
+    }
+    Set<MethodInterfacePair> pairs = new HashSet<>();
+    // Methods inherited from interfaces that are not annotated with @ActivityInterface
+    Set<MethodWrapper> ignored = new HashSet<>();
+    getAnnotatedInterfaceMethodsFromImplementation(iClass, annotationClass, ignored, pairs);
+    if (!ignored.isEmpty()) {
+      throw new IllegalStateException("Not empty ignored: " + ignored);
+    }
+    return pairs;
+  }
+
+  private static void getAnnotatedInterfaceMethodsFromImplementation(
       Class<?> current,
       Class<? extends Annotation> annotationClass,
       Set<MethodWrapper> methods,
@@ -368,7 +390,8 @@ private void getAnnotatedInterfaceMethods(
     Class<?>[] interfaces = current.getInterfaces();
     for (int i = 0; i < interfaces.length; i++) {
       Class<?> anInterface = interfaces[i];
-      getAnnotatedInterfaceMethods(anInterface, annotationClass, ourMethods, result);
+      getAnnotatedInterfaceMethodsFromImplementation(
+          anInterface, annotationClass, ourMethods, result);
     }
     Annotation annotation = current.getAnnotation(annotationClass);
     if (annotation == null) {

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

@@ -177,7 +177,8 @@ public <T> T newActivityStub(Class<T> activityInterface) {
             .setHeartbeatTimeout(Duration.ofSeconds(1))
             .build();
     InvocationHandler invocationHandler =
-        ActivityInvocationHandler.newInstance(options, new TestActivityExecutor(workflowService));
+        ActivityInvocationHandler.newInstance(
+            activityInterface, options, new TestActivityExecutor(workflowService));
     invocationHandler = new DeterministicRunnerWrapper(invocationHandler);
     return ActivityInvocationHandlerBase.newProxy(activityInterface, invocationHandler);
   }

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

@@ -149,7 +149,7 @@ public static long currentTimeMillis() {
   public static <T> T newActivityStub(Class<T> activityInterface, ActivityOptions options) {
     WorkflowInterceptor decisionContext = WorkflowInternal.getWorkflowInterceptor();
     InvocationHandler invocationHandler =
-        ActivityInvocationHandler.newInstance(options, decisionContext);
+        ActivityInvocationHandler.newInstance(activityInterface, options, decisionContext);
     return ActivityInvocationHandlerBase.newProxy(activityInterface, invocationHandler);
   }
 
@@ -162,7 +162,7 @@ public static <T> T newLocalActivityStub(
       Class<T> activityInterface, LocalActivityOptions options) {
     WorkflowInterceptor decisionContext = WorkflowInternal.getWorkflowInterceptor();
     InvocationHandler invocationHandler =
-        LocalActivityInvocationHandler.newInstance(options, decisionContext);
+        LocalActivityInvocationHandler.newInstance(activityInterface, options, decisionContext);
     return ActivityInvocationHandlerBase.newProxy(activityInterface, invocationHandler);
   }
 

src/test/java/com/uber/cadence/internal/testing/ActivityTestingTest.java

@@ -33,6 +33,8 @@
 import com.uber.cadence.workflow.ActivityFailureException;
 import io.netty.util.internal.ConcurrentSet;
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 import org.apache.thrift.TException;
@@ -252,4 +254,63 @@ public void testHeartbeatIntermittentError() throws TException, InterruptedExcep
     activity.activity1();
     assertEquals(3, count.get());
   }
+
+  public interface A {
+    void a();
+  }
+
+  @ActivityInterface
+  public interface B extends A {
+    void b();
+  }
+
+  @ActivityInterface
+  public interface C extends B, A {
+    void c();
+  }
+
+  public class CImpl implements C {
+    private List<String> invocations = new ArrayList<>();
+
+    @Override
+    public void a() {
+      invocations.add("a");
+    }
+
+    @Override
+    public void b() {
+      invocations.add("b");
+    }
+
+    @Override
+    public void c() {
+      invocations.add("c");
+    }
+  }
+
+  @Test
+  public void testInvokingActivityByBaseInterface() {
+    CImpl impl = new CImpl();
+    testEnvironment.registerActivitiesImplementations(impl);
+    try {
+      testEnvironment.newActivityStub(A.class);
+      fail("A doesn't implement activity");
+    } catch (IllegalArgumentException e) {
+      // expected as A doesn't implement any activity
+    }
+    B b = testEnvironment.newActivityStub(B.class);
+    b.a();
+    b.b();
+    C c = testEnvironment.newActivityStub(C.class);
+    c.a();
+    c.b();
+    c.c();
+    List<String> expected = new ArrayList<>();
+    expected.add("a");
+    expected.add("b");
+    expected.add("a");
+    expected.add("b");
+    expected.add("c");
+    assertEquals(expected, impl.invocations);
+  }
 }

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

@@ -5441,6 +5441,7 @@ public interface GreetingWorkflow {
     void createGreeting(String name);
   }
 
+  @ActivityInterface
   public interface GreetingActivities {
     @ActivityMethod
     String composeGreeting(String string);