builder pattern + use latest protobuf commit

Signed-off-by: Cassandra Coyle <cassie@diagrid.io>

Author: cicoyle

client/build.gradle

@@ -45,16 +45,15 @@ dependencies {
 
     // Netty dependencies for TLS
     implementation "io.grpc:grpc-netty-shaded:${grpcVersion}"
-    implementation "io.netty:netty-handler:4.1.94.Final"
+    implementation 'io.netty:netty-handler:4.1.119.Final'
     implementation "io.netty:netty-tcnative-boringssl-static:2.0.59.Final"
 
     // Add Netty dependencies to test classpath
     testImplementation "io.grpc:grpc-netty-shaded:${grpcVersion}"
-    testImplementation "io.netty:netty-handler:4.1.94.Final"
+    testImplementation 'io.netty:netty-handler:4.1.119.Final'
     testImplementation "io.netty:netty-tcnative-boringssl-static:2.0.59.Final"
 
-    testImplementation 'org.bouncycastle:bcprov-jdk15on:1.70'
-    testImplementation 'org.bouncycastle:bcpkix-jdk15on:1.70'
+    testImplementation 'org.bouncycastle:bcprov-jdk15on:1.78'
 }
 
 compileJava {

client/src/main/java/io/dapr/durabletask/TaskOptions.java

@@ -10,49 +10,53 @@ public final class TaskOptions {
     private final RetryHandler retryHandler;
     private final String appID;
 
-    public TaskOptions(RetryPolicy retryPolicy, RetryHandler retryHandler, String appID) {
-        this.retryPolicy = retryPolicy;
-        this.retryHandler = retryHandler;
-        this.appID = appID;
+    private TaskOptions(Builder builder) {
+        this.retryPolicy = builder.retryPolicy;
+        this.retryHandler = builder.retryHandler;
+        this.appID = builder.appID;
     }
 
-    public TaskOptions(RetryPolicy retryPolicy, RetryHandler retryHandler) {
-        this.retryPolicy = retryPolicy;
-        this.retryHandler = retryHandler;
-        this.appID = null;
+    /**
+     * Creates a new builder for {@code TaskOptions}.
+     * @return a new builder instance
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    /**
+     * Creates a new {@code TaskOptions} object with default values.
+     * @return a new TaskOptions instance with no configuration
+     */
+    public static TaskOptions create() {
+        return new Builder().build();
     }
 
     /**
      * Creates a new {@code TaskOptions} object from a {@link RetryPolicy}.
      * @param retryPolicy the retry policy to use in the new {@code TaskOptions} object.
+     * @return a new TaskOptions instance with the specified retry policy
      */
-    public TaskOptions(RetryPolicy retryPolicy) {
-        this(retryPolicy, null, null);
+    public static TaskOptions withRetryPolicy(RetryPolicy retryPolicy) {
+        return new Builder().retryPolicy(retryPolicy).build();
     }
 
     /**
      * Creates a new {@code TaskOptions} object from a {@link RetryHandler}.
      * @param retryHandler the retry handler to use in the new {@code TaskOptions} object.
+     * @return a new TaskOptions instance with the specified retry handler
      */
-    public TaskOptions(RetryHandler retryHandler) {
-        this(null, retryHandler, null);
+    public static TaskOptions withRetryHandler(RetryHandler retryHandler) {
+        return new Builder().retryHandler(retryHandler).build();
     }
 
     /**
      * Creates a new {@code TaskOptions} object with the specified app ID.
      * @param appID the app ID to use for cross-app workflow routing
+     * @return a new TaskOptions instance with the specified app ID
      */
-    public TaskOptions(String appID) {
-        this(null, null, appID);
-    }
-
-    /**
-     * Creates a new {@code TaskOptions} object with the specified retry policy and app ID.
-     * @param retryPolicy the retry policy to use
-     * @param appID the app ID to use for cross-app workflow routing
-     */
-    public TaskOptions(RetryPolicy retryPolicy, String appID) {
-        this(retryPolicy, null, appID);
+    public static TaskOptions withAppID(String appID) {
+        return new Builder().appID(appID).build();
     }
 
     boolean hasRetryPolicy() {
@@ -90,4 +94,55 @@ public String getAppID() {
     boolean hasAppID() {
         return this.appID != null && !this.appID.isEmpty();
     }
+
+    /**
+     * Builder for creating {@code TaskOptions} instances.
+     */
+    public static final class Builder {
+        private RetryPolicy retryPolicy;
+        private RetryHandler retryHandler;
+        private String appID;
+
+        private Builder() {
+            // Private constructor -enforces using TaskOptions.builder()
+        }
+
+        /**
+         * Sets the retry policy for the task options.
+         * @param retryPolicy the retry policy to use
+         * @return this builder instance for method chaining
+         */
+        public Builder retryPolicy(RetryPolicy retryPolicy) {
+            this.retryPolicy = retryPolicy;
+            return this;
+        }
+
+        /**
+         * Sets the retry handler for the task options.
+         * @param retryHandler the retry handler to use
+         * @return this builder instance for method chaining
+         */
+        public Builder retryHandler(RetryHandler retryHandler) {
+            this.retryHandler = retryHandler;
+            return this;
+        }
+
+        /**
+         * Sets the app ID for cross-app workflow routing.
+         * @param appID the app ID to use
+         * @return this builder instance for method chaining
+         */
+        public Builder appID(String appID) {
+            this.appID = appID;
+            return this;
+        }
+
+        /**
+         * Builds a new {@code TaskOptions} instance with the configured values.
+         * @return a new TaskOptions instance
+         */
+        public TaskOptions build() {
+            return new TaskOptions(this);
+        }
+    }
 }

client/src/main/java/io/dapr/durabletask/TaskOrchestrationExecutor.java

@@ -283,12 +283,12 @@ public <V> Task<V> callActivity(
             // Add router information for cross-app routing
             // Router always has a source app ID from EXECUTIONSTARTED event
             TaskRouter.Builder routerBuilder = TaskRouter.newBuilder()
-                .setSource(this.appId);
+                .setSourceAppID(this.appId);
 
             // Add target app ID if specified in options
             if (options != null && options.hasAppID()) {
                 String targetAppId = options.getAppID();
-                routerBuilder.setTarget(targetAppId);
+                routerBuilder.setTargetAppID(targetAppId);
                 this.logger.fine(() -> String.format(
                 "cross app routing detected: source=%s, target=%s",
                 this.appId, targetAppId));
@@ -303,10 +303,10 @@ public <V> Task<V> callActivity(
                         .setId(id)
                         .setScheduleTask(scheduleTaskBuilder);
                 TaskRouter.Builder actionRouterBuilder = TaskRouter.newBuilder()
-                        .setSource(this.appId);
+                        .setSourceAppID(this.appId);
                 if (options != null && options.hasAppID()) {
                     String targetAppId = options.getAppID();
-                    actionRouterBuilder.setTarget(targetAppId);
+                    actionRouterBuilder.setTargetAppID(targetAppId);
                 }
 
                 actionBuilder.setRouter(actionRouterBuilder.build());
@@ -874,7 +874,7 @@ private void processEvent(HistoryEvent e) {
                         this.setInput(executionStarted.getInput().getValue());
                         this.setInstanceId(executionStarted.getOrchestrationInstance().getInstanceId());
                         this.logger.fine(() -> this.instanceId + ": Workflow execution started");
-                        this.appId = e.getRouter().getSource();
+                        this.appId = e.getRouter().getSourceAppID();
 
                         // Create and invoke the workflow orchestrator
                         TaskOrchestrationFactory factory = TaskOrchestrationExecutor.this.orchestrationFactories.get(executionStarted.getName());

client/src/test/java/io/dapr/durabletask/ErrorHandlingIntegrationTests.java

@@ -112,7 +112,7 @@ public void retryActivityFailures(int maxNumberOfAttempts) throws TimeoutExcepti
             ctx.callActivity(
                     "BustedActivity",
                     null,
-                    new TaskOptions(retryPolicy)).await();
+                    TaskOptions.withRetryPolicy(retryPolicy)).await();
         });
     }
 
@@ -125,7 +125,7 @@ public void retryActivityFailuresWithCustomLogic(int maxNumberOfAttempts) throws
         // Run the test and get back the details of the last failure
         this.retryOnFailuresCoreTest(maxNumberOfAttempts, maxNumberOfAttempts, ctx -> {
             RetryHandler retryHandler = getCommonRetryHandler(retryHandlerCalls, maxNumberOfAttempts);
-            TaskOptions options = new TaskOptions(retryHandler);
+            TaskOptions options = TaskOptions.withRetryHandler(retryHandler);
             ctx.callActivity("BustedActivity", null, options).await();
         });
 
@@ -194,7 +194,7 @@ public void retrySubOrchestratorFailures(int maxNumberOfAttempts) throws Timeout
                         "BustedSubOrchestrator",
                         null,
                         null,
-                        new TaskOptions(retryPolicy)).await();
+                        TaskOptions.withRetryPolicy(retryPolicy)).await();
             });
     }
 
@@ -207,7 +207,7 @@ public void retrySubOrchestrationFailuresWithCustomLogic(int maxNumberOfAttempts
         // Run the test and get back the details of the last failure
         this.retryOnFailuresCoreTest(maxNumberOfAttempts, maxNumberOfAttempts, ctx -> {
             RetryHandler retryHandler = getCommonRetryHandler(retryHandlerCalls, maxNumberOfAttempts);
-            TaskOptions options = new TaskOptions(retryHandler);
+            TaskOptions options = TaskOptions.withRetryHandler(retryHandler);
             ctx.callSubOrchestrator("BustedSubOrchestrator", null, null, options).await();
         });
 

client/src/test/java/io/dapr/durabletask/IntegrationTests.java

@@ -1370,7 +1370,7 @@ void activityAllOf() throws IOException, TimeoutException {
         final int activityCount = 10;
         final AtomicBoolean throwException = new AtomicBoolean(true);
         final RetryPolicy retryPolicy = new RetryPolicy(2, Duration.ofSeconds(5));
-        final TaskOptions taskOptions = new TaskOptions(retryPolicy);
+        final TaskOptions taskOptions = TaskOptions.withRetryPolicy(retryPolicy);
 
         DurableTaskGrpcWorker worker = this.createWorkerBuilder()
                 .addOrchestrator(orchestratorName, ctx -> {
@@ -1428,7 +1428,7 @@ void activityAllOfException() throws IOException, TimeoutException {
         final String result = "test fail";
         final int activityMiddle = 5;
         final RetryPolicy retryPolicy = new RetryPolicy(2, Duration.ofSeconds(5));
-        final TaskOptions taskOptions = new TaskOptions(retryPolicy);
+        final TaskOptions taskOptions = TaskOptions.withRetryPolicy(retryPolicy);
 
         DurableTaskGrpcWorker worker = this.createWorkerBuilder()
                 .addOrchestrator(orchestratorName, ctx -> {
@@ -1491,7 +1491,7 @@ void activityAnyOf() throws IOException, TimeoutException {
         final int activityCount = 10;
         final AtomicBoolean throwException = new AtomicBoolean(true);
         final RetryPolicy retryPolicy = new RetryPolicy(2, Duration.ofSeconds(5));
-        final TaskOptions taskOptions = new TaskOptions(retryPolicy);
+        final TaskOptions taskOptions = TaskOptions.withRetryPolicy(retryPolicy);
 
         DurableTaskGrpcWorker worker = this.createWorkerBuilder()
                 .addOrchestrator(orchestratorName, ctx -> {
@@ -1585,7 +1585,7 @@ public void taskExecutionIdTest() {
         var orchestratorName = "test-task-execution-id";
         var retryActivityName = "RetryN";
         final RetryPolicy retryPolicy = new RetryPolicy(4, Duration.ofSeconds(3));
-        final TaskOptions taskOptions = new TaskOptions(retryPolicy);
+        final TaskOptions taskOptions = TaskOptions.withRetryPolicy(retryPolicy);
 
         var execMap = new HashMap<String, Integer>();
 

client/src/test/java/io/dapr/durabletask/TaskOptionsTest.java

@@ -25,7 +25,7 @@ public class TaskOptionsTest {
 
     @Test
     void taskOptionsWithAppID() {
-        TaskOptions options = new TaskOptions("app1");
+        TaskOptions options = TaskOptions.withAppID("app1");
 
         assertTrue(options.hasAppID());
         assertEquals("app1", options.getAppID());
@@ -36,7 +36,10 @@ void taskOptionsWithAppID() {
     @Test
     void taskOptionsWithRetryPolicyAndAppID() {
         RetryPolicy retryPolicy = new RetryPolicy(3, Duration.ofSeconds(1));
-        TaskOptions options = new TaskOptions(retryPolicy, null, "app2");
+        TaskOptions options = TaskOptions.builder()
+                .retryPolicy(retryPolicy)
+                .appID("app2")
+                .build();
 
         assertTrue(options.hasAppID());
         assertEquals("app2", options.getAppID());
@@ -53,7 +56,10 @@ public boolean handle(RetryContext context) {
                 return context.getLastAttemptNumber() < 2;
             }
         };
-        TaskOptions options = new TaskOptions(null, retryHandler, "app3");
+        TaskOptions options = TaskOptions.builder()
+                .retryHandler(retryHandler)
+                .appID("app3")
+                .build();
 
         assertTrue(options.hasAppID());
         assertEquals("app3", options.getAppID());
@@ -64,25 +70,76 @@ public boolean handle(RetryContext context) {
 
     @Test
     void taskOptionsWithoutAppID() {
-        TaskOptions options = new TaskOptions(null, null, null);
+        TaskOptions options = TaskOptions.create();
 
         assertFalse(options.hasAppID());
         assertNull(options.getAppID());
     }
 
     @Test
     void taskOptionsWithEmptyAppID() {
-        TaskOptions options = new TaskOptions("");
+        TaskOptions options = TaskOptions.withAppID("");
 
         assertFalse(options.hasAppID());
         assertEquals("", options.getAppID());
     }
 
     @Test
     void taskOptionsWithNullAppID() {
-        TaskOptions options = new TaskOptions(null, null, null);
+        TaskOptions options = TaskOptions.builder().appID(null).build();
 
         assertFalse(options.hasAppID());
         assertNull(options.getAppID());
     }
+
+    @Test
+    void taskOptionsWithRetryPolicy() {
+        RetryPolicy retryPolicy = new RetryPolicy(5, Duration.ofMinutes(1));
+        TaskOptions options = TaskOptions.withRetryPolicy(retryPolicy);
+        
+        assertTrue(options.hasRetryPolicy());
+        assertEquals(retryPolicy, options.getRetryPolicy());
+        assertFalse(options.hasRetryHandler());
+        assertFalse(options.hasAppID());
+    }
+
+    @Test
+    void taskOptionsWithRetryHandler() {
+        RetryHandler retryHandler = new RetryHandler() {
+            @Override
+            public boolean handle(RetryContext context) {
+                return context.getLastAttemptNumber() < 3;
+            }
+        };
+        TaskOptions options = TaskOptions.withRetryHandler(retryHandler);
+        
+        assertTrue(options.hasRetryHandler());
+        assertEquals(retryHandler, options.getRetryHandler());
+        assertFalse(options.hasRetryPolicy());
+        assertFalse(options.hasAppID());
+    }
+
+    @Test
+    void taskOptionsWithBuilderChaining() {
+        RetryPolicy retryPolicy = new RetryPolicy(2, Duration.ofSeconds(30));
+        RetryHandler retryHandler = new RetryHandler() {
+            @Override
+            public boolean handle(RetryContext context) {
+                return context.getLastAttemptNumber() < 1;
+            }
+        };
+        
+        TaskOptions options = TaskOptions.builder()
+                .retryPolicy(retryPolicy)
+                .retryHandler(retryHandler)
+                .appID("test-app")
+                .build();
+        
+        assertTrue(options.hasRetryPolicy());
+        assertEquals(retryPolicy, options.getRetryPolicy());
+        assertTrue(options.hasRetryHandler());
+        assertEquals(retryHandler, options.getRetryHandler());
+        assertTrue(options.hasAppID());
+        assertEquals("test-app", options.getAppID());
+    }
 }