From 6fde99ec86909f68f3679220f224e2799a84460b Mon Sep 17 00:00:00 2001 From: Siri Varma Vegiraju Date: Fri, 13 Mar 2026 14:45:10 -0700 Subject: [PATCH 01/27] feat: Add compensation workflow pattern to Spring Boot examples Port the BookTrip compensation (Saga) workflow from the plain Java examples into the Spring Boot workflow patterns module, adding @Component-annotated activities and a /wfp/compensation REST endpoint. Co-Authored-By: Claude Opus 4.6 Signed-off-by: Siri Varma Vegiraju --- .../wfp/WorkflowPatternsRestController.java | 14 +++ .../wfp/compensation/BookCarActivity.java | 42 ++++++++ .../wfp/compensation/BookFlightActivity.java | 42 ++++++++ .../wfp/compensation/BookHotelActivity.java | 40 ++++++++ .../wfp/compensation/BookTripWorkflow.java | 97 +++++++++++++++++++ .../wfp/compensation/CancelCarActivity.java | 42 ++++++++ .../compensation/CancelFlightActivity.java | 42 ++++++++ .../wfp/compensation/CancelHotelActivity.java | 42 ++++++++ 8 files changed, 361 insertions(+) create mode 100644 spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookCarActivity.java create mode 100644 spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookFlightActivity.java create mode 100644 spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookHotelActivity.java create mode 100644 spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookTripWorkflow.java create mode 100644 spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelCarActivity.java create mode 100644 spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelFlightActivity.java create mode 100644 spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelHotelActivity.java diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/WorkflowPatternsRestController.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/WorkflowPatternsRestController.java index 4bb1b0a241..9381152f18 100644 --- a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/WorkflowPatternsRestController.java +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/WorkflowPatternsRestController.java @@ -15,6 +15,7 @@ import io.dapr.spring.workflows.config.EnableDaprWorkflows; import io.dapr.springboot.examples.wfp.chain.ChainWorkflow; +import io.dapr.springboot.examples.wfp.compensation.BookTripWorkflow; import io.dapr.springboot.examples.wfp.child.ParentWorkflow; import io.dapr.springboot.examples.wfp.continueasnew.CleanUpLog; import io.dapr.springboot.examples.wfp.continueasnew.ContinueAsNewWorkflow; @@ -191,6 +192,19 @@ public Decision suspendResumeContinue(@RequestParam("orderId") String orderId, @ return workflowInstanceStatus.readOutputAs(Decision.class); } + /** + * Run Compensation Demo Workflow (Book Trip with Saga pattern). + * @return the output of the BookTripWorkflow execution + */ + @PostMapping("wfp/compensation") + public String compensation() throws TimeoutException { + String instanceId = daprWorkflowClient.scheduleNewWorkflow(BookTripWorkflow.class); + logger.info("Workflow instance " + instanceId + " started"); + return daprWorkflowClient + .waitForWorkflowCompletion(instanceId, Duration.ofSeconds(30), true) + .readOutputAs(String.class); + } + @PostMapping("wfp/durationtimer") public String durationTimerWorkflow() { return daprWorkflowClient.scheduleNewWorkflow(DurationTimerWorkflow.class); diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookCarActivity.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookCarActivity.java new file mode 100644 index 0000000000..fc83447b3a --- /dev/null +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookCarActivity.java @@ -0,0 +1,42 @@ +/* + * Copyright 2025 The Dapr Authors + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file 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.dapr.springboot.examples.wfp.compensation; + +import io.dapr.workflows.WorkflowActivity; +import io.dapr.workflows.WorkflowActivityContext; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.concurrent.TimeUnit; + +import org.springframework.stereotype.Component; + +@Component +public class BookCarActivity implements WorkflowActivity { + private static final Logger logger = LoggerFactory.getLogger(BookCarActivity.class); + + @Override + public Object run(WorkflowActivityContext ctx) { + logger.info("Starting Activity: " + ctx.getName()); + + try { + TimeUnit.SECONDS.sleep(2); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + + logger.info("Forcing Failure to trigger compensation for activity: " + ctx.getName()); + throw new RuntimeException("Failed to book car"); + } +} diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookFlightActivity.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookFlightActivity.java new file mode 100644 index 0000000000..cacaf721c8 --- /dev/null +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookFlightActivity.java @@ -0,0 +1,42 @@ +/* + * Copyright 2025 The Dapr Authors + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file 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.dapr.springboot.examples.wfp.compensation; + +import io.dapr.workflows.WorkflowActivity; +import io.dapr.workflows.WorkflowActivityContext; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Component; + +import java.util.concurrent.TimeUnit; + +@Component +public class BookFlightActivity implements WorkflowActivity { + private static final Logger logger = LoggerFactory.getLogger(BookFlightActivity.class); + + @Override + public Object run(WorkflowActivityContext ctx) { + logger.info("Starting Activity: " + ctx.getName()); + + try { + TimeUnit.SECONDS.sleep(2); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + + String result = "Flight booked successfully"; + logger.info("Activity completed with result: " + result); + return result; + } +} diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookHotelActivity.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookHotelActivity.java new file mode 100644 index 0000000000..7b82fb166b --- /dev/null +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookHotelActivity.java @@ -0,0 +1,40 @@ +/* + * Copyright 2025 The Dapr Authors + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file 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.dapr.springboot.examples.wfp.compensation; + +import io.dapr.workflows.WorkflowActivity; +import io.dapr.workflows.WorkflowActivityContext; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Component; + +@Component +public class BookHotelActivity implements WorkflowActivity { + private static final Logger logger = LoggerFactory.getLogger(BookHotelActivity.class); + + @Override + public Object run(WorkflowActivityContext ctx) { + logger.info("Starting Activity: " + ctx.getName()); + + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + } + + String result = "Hotel booked successfully"; + logger.info("Activity completed with result: " + result); + return result; + } +} diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookTripWorkflow.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookTripWorkflow.java new file mode 100644 index 0000000000..ecb955cb9b --- /dev/null +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookTripWorkflow.java @@ -0,0 +1,97 @@ +/* + * Copyright 2025 The Dapr Authors + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file 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.dapr.springboot.examples.wfp.compensation; + +import io.dapr.durabletask.TaskFailedException; +import io.dapr.workflows.Workflow; +import io.dapr.workflows.WorkflowStub; +import io.dapr.workflows.WorkflowTaskOptions; +import io.dapr.workflows.WorkflowTaskRetryPolicy; +import org.springframework.stereotype.Component; + +import java.time.Duration; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +@Component +public class BookTripWorkflow implements Workflow { + @Override + public WorkflowStub create() { + return ctx -> { + ctx.getLogger().info("Starting Workflow: " + ctx.getName()); + List compensations = new ArrayList<>(); + + WorkflowTaskRetryPolicy compensationRetryPolicy = WorkflowTaskRetryPolicy.newBuilder() + .setFirstRetryInterval(Duration.ofSeconds(1)) + .setMaxNumberOfAttempts(3) + .build(); + + WorkflowTaskOptions compensationOptions = new WorkflowTaskOptions(compensationRetryPolicy); + + try { + String flightResult = ctx.callActivity( + BookFlightActivity.class.getName(), null, String.class).await(); + ctx.getLogger().info("Flight booking completed: {}", flightResult); + compensations.add("CancelFlight"); + + String hotelResult = ctx.callActivity( + BookHotelActivity.class.getName(), null, String.class).await(); + ctx.getLogger().info("Hotel booking completed: {}", hotelResult); + compensations.add("CancelHotel"); + + String carResult = ctx.callActivity( + BookCarActivity.class.getName(), null, String.class).await(); + ctx.getLogger().info("Car booking completed: {}", carResult); + compensations.add("CancelCar"); + + String result = String.format("%s, %s, %s", flightResult, hotelResult, carResult); + ctx.getLogger().info("Trip booked successfully: {}", result); + ctx.complete(result); + + } catch (TaskFailedException e) { + ctx.getLogger().info("******** executing compensation logic ********"); + ctx.getLogger().error("Activity failed: {}", e.getMessage()); + + Collections.reverse(compensations); + for (String compensation : compensations) { + try { + switch (compensation) { + case "CancelCar": + String carCancelResult = ctx.callActivity( + CancelCarActivity.class.getName(), null, compensationOptions, String.class).await(); + ctx.getLogger().info("Car cancellation completed: {}", carCancelResult); + break; + case "CancelHotel": + String hotelCancelResult = ctx.callActivity( + CancelHotelActivity.class.getName(), null, compensationOptions, String.class).await(); + ctx.getLogger().info("Hotel cancellation completed: {}", hotelCancelResult); + break; + case "CancelFlight": + String flightCancelResult = ctx.callActivity( + CancelFlightActivity.class.getName(), null, compensationOptions, String.class).await(); + ctx.getLogger().info("Flight cancellation completed: {}", flightCancelResult); + break; + default: + break; + } + } catch (TaskFailedException ex) { + ctx.getLogger().error("Activity failed during compensation: {}", ex.getMessage()); + } + } + ctx.complete("Workflow failed, compensation applied"); + } + }; + } +} diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelCarActivity.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelCarActivity.java new file mode 100644 index 0000000000..99e78afa86 --- /dev/null +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelCarActivity.java @@ -0,0 +1,42 @@ +/* + * Copyright 2025 The Dapr Authors + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file 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.dapr.springboot.examples.wfp.compensation; + +import io.dapr.workflows.WorkflowActivity; +import io.dapr.workflows.WorkflowActivityContext; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Component; + +import java.util.concurrent.TimeUnit; + +@Component +public class CancelCarActivity implements WorkflowActivity { + private static final Logger logger = LoggerFactory.getLogger(CancelCarActivity.class); + + @Override + public Object run(WorkflowActivityContext ctx) { + logger.info("Starting Activity: " + ctx.getName()); + + try { + TimeUnit.SECONDS.sleep(2); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + + String result = "Car canceled successfully"; + logger.info("Activity completed with result: " + result); + return result; + } +} diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelFlightActivity.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelFlightActivity.java new file mode 100644 index 0000000000..4bd3fbe25d --- /dev/null +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelFlightActivity.java @@ -0,0 +1,42 @@ +/* + * Copyright 2025 The Dapr Authors + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file 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.dapr.springboot.examples.wfp.compensation; + +import io.dapr.workflows.WorkflowActivity; +import io.dapr.workflows.WorkflowActivityContext; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Component; + +import java.util.concurrent.TimeUnit; + +@Component +public class CancelFlightActivity implements WorkflowActivity { + private static final Logger logger = LoggerFactory.getLogger(CancelFlightActivity.class); + + @Override + public Object run(WorkflowActivityContext ctx) { + logger.info("Starting Activity: " + ctx.getName()); + + try { + TimeUnit.SECONDS.sleep(2); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + + String result = "Flight canceled successfully"; + logger.info("Activity completed with result: " + result); + return result; + } +} diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelHotelActivity.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelHotelActivity.java new file mode 100644 index 0000000000..e5887c2a60 --- /dev/null +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelHotelActivity.java @@ -0,0 +1,42 @@ +/* + * Copyright 2025 The Dapr Authors + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file 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.dapr.springboot.examples.wfp.compensation; + +import io.dapr.workflows.WorkflowActivity; +import io.dapr.workflows.WorkflowActivityContext; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Component; + +import java.util.concurrent.TimeUnit; + +@Component +public class CancelHotelActivity implements WorkflowActivity { + private static final Logger logger = LoggerFactory.getLogger(CancelHotelActivity.class); + + @Override + public Object run(WorkflowActivityContext ctx) { + logger.info("Starting Activity: " + ctx.getName()); + + try { + TimeUnit.SECONDS.sleep(2); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + + String result = "Hotel canceled successfully"; + logger.info("Activity completed with result: " + result); + return result; + } +} From 80d09f8e78151aa14bfd0bfd053a995dd3c767a7 Mon Sep 17 00:00:00 2001 From: Siri Varma Vegiraju Date: Fri, 13 Mar 2026 16:02:33 -0700 Subject: [PATCH 02/27] Apply suggestions from code review Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> Signed-off-by: Siri Varma Vegiraju --- .../springboot/examples/wfp/compensation/BookCarActivity.java | 1 + .../examples/wfp/compensation/BookFlightActivity.java | 1 + .../examples/wfp/compensation/BookHotelActivity.java | 2 ++ .../examples/wfp/compensation/BookTripWorkflow.java | 4 ++-- .../examples/wfp/compensation/CancelCarActivity.java | 1 + .../examples/wfp/compensation/CancelFlightActivity.java | 1 + .../examples/wfp/compensation/CancelHotelActivity.java | 1 + 7 files changed, 9 insertions(+), 2 deletions(-) diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookCarActivity.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookCarActivity.java index fc83447b3a..0026e674df 100644 --- a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookCarActivity.java +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookCarActivity.java @@ -33,6 +33,7 @@ public Object run(WorkflowActivityContext ctx) { try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { + Thread.currentThread().interrupt(); throw new RuntimeException(e); } diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookFlightActivity.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookFlightActivity.java index cacaf721c8..450942f6e0 100644 --- a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookFlightActivity.java +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookFlightActivity.java @@ -32,6 +32,7 @@ public Object run(WorkflowActivityContext ctx) { try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { + Thread.currentThread().interrupt(); throw new RuntimeException(e); } diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookHotelActivity.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookHotelActivity.java index 7b82fb166b..b4434ad17f 100644 --- a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookHotelActivity.java +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookHotelActivity.java @@ -31,6 +31,8 @@ public Object run(WorkflowActivityContext ctx) { Thread.sleep(2000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); + logger.warn("Activity '{}' was interrupted.", ctx.getName(), e); + throw new RuntimeException("Activity was interrupted", e); } String result = "Hotel booked successfully"; diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookTripWorkflow.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookTripWorkflow.java index ecb955cb9b..9f2253053f 100644 --- a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookTripWorkflow.java +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/BookTripWorkflow.java @@ -62,7 +62,7 @@ public WorkflowStub create() { } catch (TaskFailedException e) { ctx.getLogger().info("******** executing compensation logic ********"); - ctx.getLogger().error("Activity failed: {}", e.getMessage()); + ctx.getLogger().error("Activity failed", e); Collections.reverse(compensations); for (String compensation : compensations) { @@ -87,7 +87,7 @@ public WorkflowStub create() { break; } } catch (TaskFailedException ex) { - ctx.getLogger().error("Activity failed during compensation: {}", ex.getMessage()); + ctx.getLogger().error("Activity failed during compensation", ex); } } ctx.complete("Workflow failed, compensation applied"); diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelCarActivity.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelCarActivity.java index 99e78afa86..9c6143e2f2 100644 --- a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelCarActivity.java +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelCarActivity.java @@ -32,6 +32,7 @@ public Object run(WorkflowActivityContext ctx) { try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { + Thread.currentThread().interrupt(); throw new RuntimeException(e); } diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelFlightActivity.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelFlightActivity.java index 4bd3fbe25d..f24970613b 100644 --- a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelFlightActivity.java +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelFlightActivity.java @@ -32,6 +32,7 @@ public Object run(WorkflowActivityContext ctx) { try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { + Thread.currentThread().interrupt(); throw new RuntimeException(e); } diff --git a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelHotelActivity.java b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelHotelActivity.java index e5887c2a60..1d4b741dcb 100644 --- a/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelHotelActivity.java +++ b/spring-boot-examples/workflows/patterns/src/main/java/io/dapr/springboot/examples/wfp/compensation/CancelHotelActivity.java @@ -32,6 +32,7 @@ public Object run(WorkflowActivityContext ctx) { try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { + Thread.currentThread().interrupt(); throw new RuntimeException(e); } From 06e07f9122b539902724bfd44d14557007b0606b Mon Sep 17 00:00:00 2001 From: Siri Varma Vegiraju Date: Thu, 19 Mar 2026 20:18:40 -0700 Subject: [PATCH 03/27] Refactor BookTripWorkflow to use CompensationHelper Signed-off-by: Siri Varma Vegiraju --- .../compensation/BookTripWorkflow.java | 74 ++++--------------- 1 file changed, 14 insertions(+), 60 deletions(-) diff --git a/examples/src/main/java/io/dapr/examples/workflows/compensation/BookTripWorkflow.java b/examples/src/main/java/io/dapr/examples/workflows/compensation/BookTripWorkflow.java index f375363edd..f8d584f52f 100644 --- a/examples/src/main/java/io/dapr/examples/workflows/compensation/BookTripWorkflow.java +++ b/examples/src/main/java/io/dapr/examples/workflows/compensation/BookTripWorkflow.java @@ -16,44 +16,35 @@ import io.dapr.durabletask.TaskFailedException; import io.dapr.workflows.Workflow; import io.dapr.workflows.WorkflowStub; -import io.dapr.workflows.WorkflowTaskOptions; -import io.dapr.workflows.WorkflowTaskRetryPolicy; - -import java.util.List; -import java.util.ArrayList; -import java.util.Collections; -import java.time.Duration; public class BookTripWorkflow implements Workflow { @Override public WorkflowStub create() { return ctx -> { ctx.getLogger().info("Starting Workflow: " + ctx.getName()); - List compensations = new ArrayList<>(); - - // Define retry policy for compensation activities - WorkflowTaskRetryPolicy compensationRetryPolicy = WorkflowTaskRetryPolicy.newBuilder() - .setFirstRetryInterval(Duration.ofSeconds(1)) - .setMaxNumberOfAttempts(3) - .build(); - - WorkflowTaskOptions compensationOptions = new WorkflowTaskOptions(compensationRetryPolicy); + CompensationHelper compensationHelper = new CompensationHelper(); try { // Book flight - String flightResult = ctx.callActivity(BookFlightActivity.class.getName(), null, String.class).await(); + compensationHelper.addCompensation("CancelFlight", () -> + ctx.callActivity(CancelFlightActivity.class.getName(), null, String.class)); + String flightResult = ctx.callActivity( + BookFlightActivity.class.getName(), null, String.class).await(); ctx.getLogger().info("Flight booking completed: {}", flightResult); - compensations.add("CancelFlight"); // Book hotel - String hotelResult = ctx.callActivity(BookHotelActivity.class.getName(), null, String.class).await(); + compensationHelper.addCompensation("CancelHotel", () -> + ctx.callActivity(CancelHotelActivity.class.getName(), null, String.class)); + String hotelResult = ctx.callActivity( + BookHotelActivity.class.getName(), null, String.class).await(); ctx.getLogger().info("Hotel booking completed: {}", hotelResult); - compensations.add("CancelHotel"); // Book car - String carResult = ctx.callActivity(BookCarActivity.class.getName(), null, String.class).await(); + compensationHelper.addCompensation("CancelCar", () -> + ctx.callActivity(CancelCarActivity.class.getName(), null, String.class)); + String carResult = ctx.callActivity( + BookCarActivity.class.getName(), null, String.class).await(); ctx.getLogger().info("Car booking completed: {}", carResult); - compensations.add("CancelCar"); String result = String.format("%s, %s, %s", flightResult, hotelResult, carResult); ctx.getLogger().info("Trip booked successfully: {}", result); @@ -62,44 +53,7 @@ public WorkflowStub create() { } catch (TaskFailedException e) { ctx.getLogger().info("******** executing compensation logic ********"); ctx.getLogger().error("Activity failed: {}", e.getMessage()); - - // Execute compensations in reverse order - Collections.reverse(compensations); - for (String compensation : compensations) { - try { - switch (compensation) { - case "CancelCar": - String carCancelResult = ctx.callActivity( - CancelCarActivity.class.getName(), - null, - compensationOptions, - String.class).await(); - ctx.getLogger().info("Car cancellation completed: {}", carCancelResult); - break; - - case "CancelHotel": - String hotelCancelResult = ctx.callActivity( - CancelHotelActivity.class.getName(), - null, - compensationOptions, - String.class).await(); - ctx.getLogger().info("Hotel cancellation completed: {}", hotelCancelResult); - break; - - case "CancelFlight": - String flightCancelResult = ctx.callActivity( - CancelFlightActivity.class.getName(), - null, - compensationOptions, - String.class).await(); - ctx.getLogger().info("Flight cancellation completed: {}", flightCancelResult); - break; - } - } catch (TaskFailedException ex) { - // Only catch TaskFailedException for actual activity failures - ctx.getLogger().error("Activity failed during compensation: {}", ex.getMessage()); - } - } + compensationHelper.compensate(); ctx.complete("Workflow failed, compensation applied"); } }; From 3226038145426565cdb3ed9c3fc5e9b18e46665b Mon Sep 17 00:00:00 2001 From: Siri Varma Vegiraju Date: Thu, 19 Mar 2026 20:19:57 -0700 Subject: [PATCH 04/27] Add CompensationHelper class for managing compensations Signed-off-by: Siri Varma Vegiraju --- .../compensation/CompensationHelper.java | 37 +++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 examples/src/main/java/io/dapr/examples/workflows/compensation/CompensationHelper.java diff --git a/examples/src/main/java/io/dapr/examples/workflows/compensation/CompensationHelper.java b/examples/src/main/java/io/dapr/examples/workflows/compensation/CompensationHelper.java new file mode 100644 index 0000000000..15901acd81 --- /dev/null +++ b/examples/src/main/java/io/dapr/examples/workflows/compensation/CompensationHelper.java @@ -0,0 +1,37 @@ +/* + * Copyright 2025 The Dapr Authors + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file 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.dapr.examples.workflows.compensation; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +public class CompensationHelper { + + private final Map compensations = new LinkedHashMap<>(); + + public void addCompensation(String name, Runnable compensation) { + compensations.put(name, compensation); + } + + public void compensate() { + List keys = new ArrayList<>(compensations.keySet()); + Collections.reverse(keys); + for (String key : keys) { + compensations.get(key).run(); + } + } +} From 95f62fe62b17b25b2730bea6e71684a109379094 Mon Sep 17 00:00:00 2001 From: Siri Varma Vegiraju Date: Mon, 16 Mar 2026 02:17:42 -0700 Subject: [PATCH 05/27] Add baggage support (#1659) * Add baggage Signed-off-by: siri-varma * Update sdk/src/test/java/io/dapr/client/DaprClientGrpcBaggageTest.java Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Signed-off-by: Siri Varma Vegiraju * Apply suggestions from code review Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Signed-off-by: Siri Varma Vegiraju * Remove empty tearDown method in test class Removed empty tearDown method from DaprClientGrpcBaggageTest. Signed-off-by: Siri Varma Vegiraju * Refactor contextWrite calls to remove casting Signed-off-by: Siri Varma Vegiraju --------- Signed-off-by: siri-varma Signed-off-by: Siri Varma Vegiraju Co-authored-by: Cassie Coyle Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- .../dapr/examples/baggage/BaggageClient.java | 99 +++++++++ .../java/io/dapr/examples/baggage/README.md | 96 +++++++++ .../main/java/io/dapr/client/DaprHttp.java | 3 +- sdk/src/main/java/io/dapr/client/Headers.java | 5 + .../grpc/DaprClientGrpcInterceptors.java | 2 + .../interceptors/DaprBaggageInterceptor.java | 64 ++++++ .../client/DaprClientGrpcBaggageTest.java | 195 ++++++++++++++++++ 7 files changed, 463 insertions(+), 1 deletion(-) create mode 100644 examples/src/main/java/io/dapr/examples/baggage/BaggageClient.java create mode 100644 examples/src/main/java/io/dapr/examples/baggage/README.md create mode 100644 sdk/src/main/java/io/dapr/internal/grpc/interceptors/DaprBaggageInterceptor.java create mode 100644 sdk/src/test/java/io/dapr/client/DaprClientGrpcBaggageTest.java diff --git a/examples/src/main/java/io/dapr/examples/baggage/BaggageClient.java b/examples/src/main/java/io/dapr/examples/baggage/BaggageClient.java new file mode 100644 index 0000000000..2f9c6b7985 --- /dev/null +++ b/examples/src/main/java/io/dapr/examples/baggage/BaggageClient.java @@ -0,0 +1,99 @@ +/* + * Copyright 2024 The Dapr Authors + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file 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.dapr.examples.baggage; + +import io.dapr.client.DaprClient; +import io.dapr.client.DaprClientBuilder; +import io.dapr.client.Headers; +import io.dapr.client.domain.HttpExtension; +import reactor.util.context.Context; + +/** + * Example demonstrating W3C Baggage propagation with the Dapr Java SDK. + * + *

Baggage allows propagating key-value pairs across service boundaries alongside + * distributed traces. This is useful for passing contextual information (e.g., user IDs, + * tenant IDs, feature flags) without modifying request payloads. + * + *

The Dapr runtime supports baggage propagation as defined by the + * W3C Baggage specification. + * + *

Usage

+ *
    + *
  1. Build and install jars: {@code mvn clean install}
    2. + *
  2. {@code cd [repo root]/examples}
    3. + *
  3. Start the target service: + * {@code dapr run --app-id target-service --app-port 3000 -- java -jar target/dapr-java-sdk-examples-exec.jar + * io.dapr.examples.invoke.http.DemoService -p 3000}
    4. + *
  4. Run the client: + * {@code dapr run -- java -jar target/dapr-java-sdk-examples-exec.jar + * io.dapr.examples.baggage.BaggageClient}
    5. + *
+ */ +public class BaggageClient { + + /** + * The main method to run the baggage example. + * + * @param args command line arguments (unused). + * @throws Exception on any error. + */ + public static void main(String[] args) throws Exception { + try (DaprClient client = new DaprClientBuilder().build()) { + + // Build the W3C Baggage header value. + // Format: key1=value1,key2=value2 + // See https://www.w3.org/TR/baggage/#header-content + String baggageValue = "userId=alice,tenantId=acme-corp,featureFlag=new-ui"; + + System.out.println("Invoking service with baggage: " + baggageValue); + + // Propagate baggage via Reactor context. + // The SDK automatically injects the "baggage" header into outgoing gRPC + // and HTTP requests when present in the Reactor context. + byte[] response = client.invokeMethod( + "target-service", + "say", + "hello with baggage", + HttpExtension.POST, + null, + byte[].class) + .contextWrite(Context.of(Headers.BAGGAGE, baggageValue)) + .block(); + + if (response != null) { + System.out.println("Response: " + new String(response)); + } + + // You can also combine baggage with tracing context. + System.out.println("\nInvoking service with baggage and tracing context..."); + response = client.invokeMethod( + "target-service", + "say", + "hello with baggage and tracing", + HttpExtension.POST, + null, + byte[].class) + .contextWrite(Context.of(Headers.BAGGAGE, baggageValue) + .put("traceparent", "00-0af7651916cd43dd8448eb211c80319c-b9c7c989f97918e1-01")) + .block(); + + if (response != null) { + System.out.println("Response: " + new String(response)); + } + + System.out.println("Done."); + } + } +} diff --git a/examples/src/main/java/io/dapr/examples/baggage/README.md b/examples/src/main/java/io/dapr/examples/baggage/README.md new file mode 100644 index 0000000000..4d55b39a1b --- /dev/null +++ b/examples/src/main/java/io/dapr/examples/baggage/README.md @@ -0,0 +1,96 @@ +# Baggage Propagation Example + +This example demonstrates [W3C Baggage](https://www.w3.org/TR/baggage/) propagation using the Dapr Java SDK. + +## Overview + +Baggage allows you to propagate key-value pairs across service boundaries alongside distributed traces. This is useful for passing contextual information — such as user IDs, tenant IDs, or feature flags — without modifying request payloads. + +The Dapr runtime supports baggage propagation as described in [Dapr PR #8649](https://github.com/dapr/dapr/pull/8649). The Java SDK propagates the `baggage` header via both gRPC metadata and HTTP headers automatically when the value is present in Reactor's context. + +## How It Works + +The SDK reads the `baggage` key from Reactor's `ContextView` and injects it into: +- **gRPC metadata** via `DaprBaggageInterceptor` +- **HTTP headers** via `DaprHttp` (added to the context-to-header allowlist) + +To propagate baggage, add it to the Reactor context using `.contextWrite()`: + +```java +import io.dapr.client.Headers; +import reactor.util.context.Context; + +client.invokeMethod("target-service", "say", "hello", HttpExtension.POST, null, byte[].class) + .contextWrite(Context.of(Headers.BAGGAGE, "userId=alice,tenantId=acme-corp")) + .block(); +``` + +The baggage value follows the [W3C Baggage header format](https://www.w3.org/TR/baggage/#header-content): +``` +key1=value1,key2=value2 +``` + +Each list-member can optionally include properties: +``` +key1=value1;property1;property2,key2=value2 +``` + +## Pre-requisites + +* [Dapr CLI](https://docs.dapr.io/getting-started/install-dapr-cli/) +* Java JDK 11 (or greater): + * [Microsoft JDK 11](https://docs.microsoft.com/en-us/java/openjdk/download#openjdk-11) + * [Oracle JDK 11](https://www.oracle.com/technetwork/java/javase/downloads/index.html#JDK11) + * [OpenJDK 11](https://jdk.java.net/11/) +* [Apache Maven](https://maven.apache.org/install.html) version 3.x. + +## Running the Example + +### 1. Build and install jars + +```sh +# From the java-sdk root directory +mvn clean install +``` + +### 2. Start the target service + +In one terminal, start the demo service: + +```sh +cd examples +dapr run --app-id target-service --app-port 3000 -- \ + java -jar target/dapr-java-sdk-examples-exec.jar \ + io.dapr.examples.invoke.http.DemoService -p 3000 +``` + +### 3. Run the baggage client + +In another terminal: + +```sh +cd examples +dapr run -- java -jar target/dapr-java-sdk-examples-exec.jar \ + io.dapr.examples.baggage.BaggageClient +``` + +You should see output like: + +``` +Invoking service with baggage: userId=alice,tenantId=acme-corp,featureFlag=new-ui +Response: ... +Done. +``` + +## Combining Baggage with Tracing + +You can propagate both baggage and tracing context together by adding multiple entries to the Reactor context: + +```java +client.invokeMethod("target-service", "say", "hello", HttpExtension.POST, null, byte[].class) + .contextWrite(Context.of(Headers.BAGGAGE, "userId=alice") + .put("traceparent", "00-0af7651916cd43dd8448eb211c80319c-b9c7c989f97918e1-01")) + .block(); +``` + +Both the `baggage` and `traceparent` headers will be propagated to downstream services via Dapr. diff --git a/sdk/src/main/java/io/dapr/client/DaprHttp.java b/sdk/src/main/java/io/dapr/client/DaprHttp.java index 0dc395834c..fd7accd998 100644 --- a/sdk/src/main/java/io/dapr/client/DaprHttp.java +++ b/sdk/src/main/java/io/dapr/client/DaprHttp.java @@ -66,7 +66,8 @@ public class DaprHttp implements AutoCloseable { /** * Context entries allowed to be in HTTP Headers. */ - private static final Set ALLOWED_CONTEXT_IN_HEADERS = Set.of("grpc-trace-bin", "traceparent", "tracestate"); + private static final Set ALLOWED_CONTEXT_IN_HEADERS = + Set.of("grpc-trace-bin", "traceparent", "tracestate", "baggage"); /** * Object mapper to parse DaprError with or without details. diff --git a/sdk/src/main/java/io/dapr/client/Headers.java b/sdk/src/main/java/io/dapr/client/Headers.java index 9ae7ebef53..5b76510e55 100644 --- a/sdk/src/main/java/io/dapr/client/Headers.java +++ b/sdk/src/main/java/io/dapr/client/Headers.java @@ -32,4 +32,9 @@ public final class Headers { * Header for Api Logging User-Agent. */ public static final String DAPR_USER_AGENT = "User-Agent"; + + /** + * W3C Baggage header for context propagation. + */ + public static final String BAGGAGE = "baggage"; } diff --git a/sdk/src/main/java/io/dapr/internal/grpc/DaprClientGrpcInterceptors.java b/sdk/src/main/java/io/dapr/internal/grpc/DaprClientGrpcInterceptors.java index 0a3b2f1131..c89255b5b1 100644 --- a/sdk/src/main/java/io/dapr/internal/grpc/DaprClientGrpcInterceptors.java +++ b/sdk/src/main/java/io/dapr/internal/grpc/DaprClientGrpcInterceptors.java @@ -15,6 +15,7 @@ import io.dapr.internal.grpc.interceptors.DaprApiTokenInterceptor; import io.dapr.internal.grpc.interceptors.DaprAppIdInterceptor; +import io.dapr.internal.grpc.interceptors.DaprBaggageInterceptor; import io.dapr.internal.grpc.interceptors.DaprMetadataReceiverInterceptor; import io.dapr.internal.grpc.interceptors.DaprTimeoutInterceptor; import io.dapr.internal.grpc.interceptors.DaprTracingInterceptor; @@ -126,6 +127,7 @@ public > T intercept( new DaprApiTokenInterceptor(this.daprApiToken), new DaprTimeoutInterceptor(this.timeoutPolicy), new DaprTracingInterceptor(context), + new DaprBaggageInterceptor(context), new DaprMetadataReceiverInterceptor(metadataConsumer)); } diff --git a/sdk/src/main/java/io/dapr/internal/grpc/interceptors/DaprBaggageInterceptor.java b/sdk/src/main/java/io/dapr/internal/grpc/interceptors/DaprBaggageInterceptor.java new file mode 100644 index 0000000000..21f471ac9e --- /dev/null +++ b/sdk/src/main/java/io/dapr/internal/grpc/interceptors/DaprBaggageInterceptor.java @@ -0,0 +1,64 @@ +/* + * Copyright 2024 The Dapr Authors + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file 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.dapr.internal.grpc.interceptors; + +import io.dapr.client.Headers; +import io.grpc.CallOptions; +import io.grpc.Channel; +import io.grpc.ClientCall; +import io.grpc.ClientInterceptor; +import io.grpc.ForwardingClientCall; +import io.grpc.Metadata; +import io.grpc.MethodDescriptor; +import reactor.util.context.ContextView; + +/** + * Injects W3C Baggage header into gRPC metadata from Reactor's context. + */ +public class DaprBaggageInterceptor implements ClientInterceptor { + + private static final Metadata.Key BAGGAGE_KEY = + Metadata.Key.of(Headers.BAGGAGE, Metadata.ASCII_STRING_MARSHALLER); + + private final ContextView context; + + /** + * Creates an instance of the baggage interceptor for gRPC. + * + * @param context Reactor's context + */ + public DaprBaggageInterceptor(ContextView context) { + this.context = context; + } + + @Override + public ClientCall interceptCall( + MethodDescriptor methodDescriptor, + CallOptions callOptions, + Channel channel) { + ClientCall clientCall = channel.newCall(methodDescriptor, callOptions); + return new ForwardingClientCall.SimpleForwardingClientCall<>(clientCall) { + @Override + public void start(final Listener responseListener, final Metadata metadata) { + if (context != null && context.hasKey(Headers.BAGGAGE)) { + String baggageValue = context.get(Headers.BAGGAGE).toString(); + if (baggageValue != null && !baggageValue.isEmpty()) { + metadata.put(BAGGAGE_KEY, baggageValue); + } + } + super.start(responseListener, metadata); + } + }; + } +} diff --git a/sdk/src/test/java/io/dapr/client/DaprClientGrpcBaggageTest.java b/sdk/src/test/java/io/dapr/client/DaprClientGrpcBaggageTest.java new file mode 100644 index 0000000000..9f9543b2b0 --- /dev/null +++ b/sdk/src/test/java/io/dapr/client/DaprClientGrpcBaggageTest.java @@ -0,0 +1,195 @@ +/* + * Copyright 2024 The Dapr Authors + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file 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.dapr.client; + +import io.dapr.internal.grpc.DaprClientGrpcInterceptors; +import io.dapr.v1.CommonProtos; +import io.dapr.v1.DaprGrpc; +import io.dapr.v1.DaprInvokeProtos; +import io.grpc.ManagedChannel; +import io.grpc.Metadata; +import io.grpc.ServerCall; +import io.grpc.ServerCallHandler; +import io.grpc.ServerInterceptor; +import io.grpc.ServerInterceptors; +import io.grpc.ServerServiceDefinition; +import io.grpc.inprocess.InProcessChannelBuilder; +import io.grpc.inprocess.InProcessServerBuilder; +import io.grpc.stub.StreamObserver; +import io.grpc.testing.GrpcCleanupRule; +import org.junit.Rule; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.migrationsupport.rules.EnableRuleMigrationSupport; +import reactor.core.publisher.Mono; +import reactor.core.publisher.MonoSink; +import reactor.util.context.Context; +import reactor.util.context.ContextView; + +import java.io.IOException; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Consumer; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +@EnableRuleMigrationSupport +public class DaprClientGrpcBaggageTest { + + private static final Metadata.Key BAGGAGE_KEY = + Metadata.Key.of(Headers.BAGGAGE, Metadata.ASCII_STRING_MARSHALLER); + + @Rule + public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule(); + + private DaprGrpc.DaprStub daprStub; + + @Test + public void testBaggagePropagated() throws IOException { + String expectedBaggage = "key1=value1,key2=value2"; + AtomicReference receivedBaggage = new AtomicReference<>(); + + setupServer((metadata) -> { + receivedBaggage.set(metadata.get(BAGGAGE_KEY)); + }); + + Context context = Context.empty().put(Headers.BAGGAGE, expectedBaggage); + + Mono result = invoke() + .contextWrite(it -> it.putAll(context)); + result.block(); + + assertEquals(expectedBaggage, receivedBaggage.get()); + } + + @Test + public void testBaggageNotPropagatedWhenAbsent() throws IOException { + AtomicReference receivedBaggage = new AtomicReference<>(); + + setupServer((metadata) -> { + receivedBaggage.set(metadata.get(BAGGAGE_KEY)); + }); + + Context context = Context.empty(); + + Mono result = invoke() + .contextWrite(it -> it.putAll(context)); + result.block(); + + assertNull(receivedBaggage.get()); + } + + @Test + public void testBaggageWithSingleEntry() throws IOException { + String expectedBaggage = "userId=alice"; + AtomicReference receivedBaggage = new AtomicReference<>(); + + setupServer((metadata) -> { + receivedBaggage.set(metadata.get(BAGGAGE_KEY)); + }); + + Context context = Context.empty().put(Headers.BAGGAGE, expectedBaggage); + + Mono result = invoke() + .contextWrite(it -> it.putAll(context)); + result.block(); + + assertEquals(expectedBaggage, receivedBaggage.get()); + } + + @Test + public void testBaggageWithTracingContext() throws IOException { + String expectedBaggage = "key1=value1"; + String traceparent = "00-0af7651916cd43dd8448eb211c80319c-b9c7c989f97918e1-01"; + AtomicReference receivedBaggage = new AtomicReference<>(); + + setupServer((metadata) -> { + receivedBaggage.set(metadata.get(BAGGAGE_KEY)); + }); + + Context context = Context.empty() + .put(Headers.BAGGAGE, expectedBaggage) + .put("traceparent", traceparent); + + Mono result = invoke() + .contextWrite(it -> it.putAll(context)); + result.block(); + + assertEquals(expectedBaggage, receivedBaggage.get()); + } + + private void setupServer(Consumer metadataAssertions) throws IOException { + DaprGrpc.DaprImplBase daprImplBase = new DaprGrpc.DaprImplBase() { + @Override + public void invokeService(DaprInvokeProtos.InvokeServiceRequest request, + StreamObserver responseObserver) { + responseObserver.onNext(CommonProtos.InvokeResponse.getDefaultInstance()); + responseObserver.onCompleted(); + } + }; + + ServerServiceDefinition service = ServerInterceptors.intercept(daprImplBase, new ServerInterceptor() { + @Override + public ServerCall.Listener interceptCall(ServerCall serverCall, + Metadata metadata, + ServerCallHandler serverCallHandler) { + metadataAssertions.accept(metadata); + return serverCallHandler.startCall(serverCall, metadata); + } + }); + + String serverName = InProcessServerBuilder.generateName(); + grpcCleanup.register(InProcessServerBuilder.forName(serverName).directExecutor() + .addService(service) + .build().start()); + + ManagedChannel channel = grpcCleanup.register( + InProcessChannelBuilder.forName(serverName).directExecutor().build()); + daprStub = DaprGrpc.newStub(channel); + } + + private Mono invoke() { + DaprInvokeProtos.InvokeServiceRequest req = + DaprInvokeProtos.InvokeServiceRequest.newBuilder().build(); + return Mono.deferContextual( + context -> this.createMono( + it -> new DaprClientGrpcInterceptors().intercept(daprStub, context).invokeService(req, it) + ) + ).then(); + } + + private Mono createMono(Consumer> consumer) { + return Mono.create(sink -> consumer.accept(createStreamObserver(sink))); + } + + private StreamObserver createStreamObserver(MonoSink sink) { + return new StreamObserver() { + @Override + public void onNext(T value) { + sink.success(value); + } + + @Override + public void onError(Throwable t) { + sink.error(new ExecutionException(t)); + } + + @Override + public void onCompleted() { + sink.success(); + } + }; + } +} From d3fcd02996f69b5f055080507bd54fa4f6a88d28 Mon Sep 17 00:00:00 2001 From: Javier Aliaga Date: Thu, 26 Mar 2026 14:22:51 +0100 Subject: [PATCH 06/27] fix: adapt to durabletask-protobuf proto file split (#1702) The dapr/durabletask-protobuf#32 PR refactored protos by concept, splitting orchestrator_service.proto into orchestration.proto, history_events.proto, and orchestrator_actions.proto. This broke the build because only the single file was being downloaded. - Download all 4 proto files in durabletask-client/pom.xml - Replace single-file URL property with base URL in parent pom - Update Java type references from OrchestratorService.* to the correct new outer classes: Orchestration, HistoryEvents, OrchestratorActions Signed-off-by: Javier Aliaga --- durabletask-client/pom.xml | 43 ++++- .../durabletask/DurableTaskGrpcWorker.java | 3 +- .../io/dapr/durabletask/FailureDetails.java | 2 +- .../durabletask/OrchestrationMetadata.java | 2 +- .../OrchestrationRuntimeStatus.java | 22 +-- .../TaskOrchestrationExecutor.java | 170 +++++++++--------- .../durabletask/TaskOrchestratorResult.java | 8 +- .../durabletask/runner/ActivityRunner.java | 7 +- .../runner/OrchestratorRunner.java | 3 +- .../SubOrchestrationCrossAppTest.java | 114 ++++++------ pom.xml | 2 +- 11 files changed, 209 insertions(+), 167 deletions(-) diff --git a/durabletask-client/pom.xml b/durabletask-client/pom.xml index b1e24d9397..41ac0f9b99 100644 --- a/durabletask-client/pom.xml +++ b/durabletask-client/pom.xml @@ -110,18 +110,57 @@ ${download-maven-plugin.version} - getDaprProto + getOrchestratorServiceProto initialize wget true - ${durabletask.proto.url} + ${durabletask.proto.baseurl}/orchestrator_service.proto orchestrator_service.proto ${protobuf.input.directory} + + getOrchestrationProto + initialize + + wget + + + true + ${durabletask.proto.baseurl}/orchestration.proto + orchestration.proto + ${protobuf.input.directory} + + + + getHistoryEventsProto + initialize + + wget + + + true + ${durabletask.proto.baseurl}/history_events.proto + history_events.proto + ${protobuf.input.directory} + + + + getOrchestratorActionsProto + initialize + + wget + + + true + ${durabletask.proto.baseurl}/orchestrator_actions.proto + orchestrator_actions.proto + ${protobuf.input.directory} + + diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/DurableTaskGrpcWorker.java b/durabletask-client/src/main/java/io/dapr/durabletask/DurableTaskGrpcWorker.java index 1e08d08049..cf3a578690 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/DurableTaskGrpcWorker.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/DurableTaskGrpcWorker.java @@ -13,6 +13,7 @@ package io.dapr.durabletask; +import io.dapr.durabletask.implementation.protobuf.Orchestration; import io.dapr.durabletask.implementation.protobuf.OrchestratorService; import io.dapr.durabletask.implementation.protobuf.TaskHubSidecarServiceGrpc; import io.dapr.durabletask.orchestration.TaskOrchestrationFactories; @@ -279,7 +280,7 @@ private Context extractTraceContext(OrchestratorService.ActivityRequest activity return Context.current(); } - OrchestratorService.TraceContext traceContext = activityRequest.getParentTraceContext(); + Orchestration.TraceContext traceContext = activityRequest.getParentTraceContext(); String traceParent = traceContext.getTraceParent(); if (traceParent.isEmpty()) { diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/FailureDetails.java b/durabletask-client/src/main/java/io/dapr/durabletask/FailureDetails.java index 357946ab31..897ac7f4e6 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/FailureDetails.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/FailureDetails.java @@ -14,7 +14,7 @@ package io.dapr.durabletask; import com.google.protobuf.StringValue; -import io.dapr.durabletask.implementation.protobuf.OrchestratorService.TaskFailureDetails; +import io.dapr.durabletask.implementation.protobuf.Orchestration.TaskFailureDetails; import javax.annotation.Nonnull; import javax.annotation.Nullable; diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationMetadata.java b/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationMetadata.java index 7f9285d034..13b0fdcd1b 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationMetadata.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationMetadata.java @@ -13,8 +13,8 @@ package io.dapr.durabletask; +import io.dapr.durabletask.implementation.protobuf.Orchestration.OrchestrationState; import io.dapr.durabletask.implementation.protobuf.OrchestratorService; -import io.dapr.durabletask.implementation.protobuf.OrchestratorService.OrchestrationState; import java.time.Instant; diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationRuntimeStatus.java b/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationRuntimeStatus.java index e9530ae815..3dde08ccb9 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationRuntimeStatus.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationRuntimeStatus.java @@ -13,16 +13,16 @@ package io.dapr.durabletask; -import io.dapr.durabletask.implementation.protobuf.OrchestratorService; +import io.dapr.durabletask.implementation.protobuf.Orchestration; -import static io.dapr.durabletask.implementation.protobuf.OrchestratorService.OrchestrationStatus.ORCHESTRATION_STATUS_CANCELED; -import static io.dapr.durabletask.implementation.protobuf.OrchestratorService.OrchestrationStatus.ORCHESTRATION_STATUS_COMPLETED; -import static io.dapr.durabletask.implementation.protobuf.OrchestratorService.OrchestrationStatus.ORCHESTRATION_STATUS_CONTINUED_AS_NEW; -import static io.dapr.durabletask.implementation.protobuf.OrchestratorService.OrchestrationStatus.ORCHESTRATION_STATUS_FAILED; -import static io.dapr.durabletask.implementation.protobuf.OrchestratorService.OrchestrationStatus.ORCHESTRATION_STATUS_PENDING; -import static io.dapr.durabletask.implementation.protobuf.OrchestratorService.OrchestrationStatus.ORCHESTRATION_STATUS_RUNNING; -import static io.dapr.durabletask.implementation.protobuf.OrchestratorService.OrchestrationStatus.ORCHESTRATION_STATUS_SUSPENDED; -import static io.dapr.durabletask.implementation.protobuf.OrchestratorService.OrchestrationStatus.ORCHESTRATION_STATUS_TERMINATED; +import static io.dapr.durabletask.implementation.protobuf.Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_CANCELED; +import static io.dapr.durabletask.implementation.protobuf.Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_COMPLETED; +import static io.dapr.durabletask.implementation.protobuf.Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_CONTINUED_AS_NEW; +import static io.dapr.durabletask.implementation.protobuf.Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_FAILED; +import static io.dapr.durabletask.implementation.protobuf.Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_PENDING; +import static io.dapr.durabletask.implementation.protobuf.Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_RUNNING; +import static io.dapr.durabletask.implementation.protobuf.Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_SUSPENDED; +import static io.dapr.durabletask.implementation.protobuf.Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_TERMINATED; /** * Enum describing the runtime status of the orchestration. @@ -75,7 +75,7 @@ public enum OrchestrationRuntimeStatus { */ STALLED; - static OrchestrationRuntimeStatus fromProtobuf(OrchestratorService.OrchestrationStatus status) { + static OrchestrationRuntimeStatus fromProtobuf(Orchestration.OrchestrationStatus status) { switch (status) { case ORCHESTRATION_STATUS_RUNNING: return RUNNING; @@ -100,7 +100,7 @@ static OrchestrationRuntimeStatus fromProtobuf(OrchestratorService.Orchestration } } - static OrchestratorService.OrchestrationStatus toProtobuf(OrchestrationRuntimeStatus status) { + static Orchestration.OrchestrationStatus toProtobuf(OrchestrationRuntimeStatus status) { switch (status) { case RUNNING: return ORCHESTRATION_STATUS_RUNNING; diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestrationExecutor.java b/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestrationExecutor.java index 1ecdcde7e1..2cf29a61dd 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestrationExecutor.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestrationExecutor.java @@ -15,8 +15,10 @@ import com.google.protobuf.StringValue; import com.google.protobuf.Timestamp; -import io.dapr.durabletask.implementation.protobuf.OrchestratorService; -import io.dapr.durabletask.implementation.protobuf.OrchestratorService.ScheduleTaskAction.Builder; +import io.dapr.durabletask.implementation.protobuf.HistoryEvents; +import io.dapr.durabletask.implementation.protobuf.Orchestration; +import io.dapr.durabletask.implementation.protobuf.OrchestratorActions; +import io.dapr.durabletask.implementation.protobuf.OrchestratorActions.ScheduleTaskAction.Builder; import io.dapr.durabletask.interruption.ContinueAsNewInterruption; import io.dapr.durabletask.interruption.OrchestratorBlockedException; import io.dapr.durabletask.orchestration.TaskOrchestrationFactories; @@ -86,8 +88,8 @@ public TaskOrchestrationExecutor( * @param newEvents list of new history events * @return the result of the orchestrator execution */ - public TaskOrchestratorResult execute(List pastEvents, - List newEvents) { + public TaskOrchestratorResult execute(List pastEvents, + List newEvents) { ContextImplTask context = new ContextImplTask(pastEvents, newEvents); boolean completed = false; @@ -140,11 +142,11 @@ private class ContextImplTask implements TaskOrchestrationContext { private String appId; // LinkedHashMap to maintain insertion order when returning the list of pending actions - private final Map pendingActions = new LinkedHashMap<>(); + private final Map pendingActions = new LinkedHashMap<>(); private final Map> openTasks = new HashMap<>(); private final Map>> outstandingEvents = new LinkedHashMap<>(); - private final List unprocessedEvents = new LinkedList<>(); - private final Queue eventsWhileSuspended = new ArrayDeque<>(); + private final List unprocessedEvents = new LinkedList<>(); + private final Queue eventsWhileSuspended = new ArrayDeque<>(); private final DataConverter dataConverter = TaskOrchestrationExecutor.this.dataConverter; private final Duration maximumTimerInterval = TaskOrchestrationExecutor.this.maximumTimerInterval; private final Logger logger = TaskOrchestrationExecutor.this.logger; @@ -161,8 +163,8 @@ private class ContextImplTask implements TaskOrchestrationContext { private String versionName; - public ContextImplTask(List pastEvents, - List newEvents) { + public ContextImplTask(List pastEvents, + List newEvents) { this.historyEventPlayer = new OrchestrationHistoryIterator(pastEvents, newEvents); } @@ -346,17 +348,16 @@ public Task callActivity( } String serializedInput = this.dataConverter.serialize(input); - Builder scheduleTaskBuilder = OrchestratorService.ScheduleTaskAction.newBuilder().setName(name) + Builder scheduleTaskBuilder = OrchestratorActions.ScheduleTaskAction.newBuilder().setName(name) .setTaskExecutionId(newUuid().toString()); if (serializedInput != null) { scheduleTaskBuilder.setInput(StringValue.of(serializedInput)); } // Add router information for cross-app routing - OrchestratorService.TaskRouter router = null; if (hasSourceAppId() && hasTargetAppId(options)) { String targetAppId = options.getAppID(); - scheduleTaskBuilder.setRouter(OrchestratorService.TaskRouter.newBuilder() + scheduleTaskBuilder.setRouter(Orchestration.TaskRouter.newBuilder() .setSourceAppID(this.appId) .setTargetAppID(targetAppId) .build()); @@ -365,17 +366,14 @@ public Task callActivity( this.appId, targetAppId)); } - // Capture for use inside lambda - final OrchestratorService.TaskRouter actionRouter = router; - TaskFactory taskFactory = () -> { int id = this.sequenceNumber++; - OrchestratorService.OrchestratorAction.Builder actionBuilder = OrchestratorService.OrchestratorAction + OrchestratorActions.OrchestratorAction.Builder actionBuilder = OrchestratorActions.OrchestratorAction .newBuilder() .setId(id) .setScheduleTask(scheduleTaskBuilder); if (hasSourceAppId() && hasTargetAppId(options)) { - actionBuilder.setRouter(OrchestratorService.TaskRouter.newBuilder() + actionBuilder.setRouter(Orchestration.TaskRouter.newBuilder() .setSourceAppID(this.appId) .setTargetAppID(options.getAppID()) .build()); @@ -465,16 +463,16 @@ public void sendEvent(String instanceId, String eventName, Object eventData) { int id = this.sequenceNumber++; String serializedEventData = this.dataConverter.serialize(eventData); - OrchestratorService.OrchestrationInstance.Builder orchestrationInstanceBuilder = - OrchestratorService.OrchestrationInstance.newBuilder() + Orchestration.OrchestrationInstance.Builder orchestrationInstanceBuilder = + Orchestration.OrchestrationInstance.newBuilder() .setInstanceId(instanceId); - OrchestratorService.SendEventAction.Builder builder = OrchestratorService + OrchestratorActions.SendEventAction.Builder builder = OrchestratorActions .SendEventAction.newBuilder().setInstance(orchestrationInstanceBuilder) .setName(eventName); if (serializedEventData != null) { builder.setData(StringValue.of(serializedEventData)); } - OrchestratorService.OrchestratorAction.Builder actionBuilder = OrchestratorService.OrchestratorAction.newBuilder() + OrchestratorActions.OrchestratorAction.Builder actionBuilder = OrchestratorActions.OrchestratorAction.newBuilder() .setId(id) .setSendEvent(builder); @@ -507,8 +505,8 @@ public Task callSubOrchestrator( } String serializedInput = this.dataConverter.serialize(input); - OrchestratorService.CreateSubOrchestrationAction.Builder createSubOrchestrationActionBuilder = - OrchestratorService.CreateSubOrchestrationAction + OrchestratorActions.CreateSubOrchestrationAction.Builder createSubOrchestrationActionBuilder = + OrchestratorActions.CreateSubOrchestrationAction .newBuilder().setName(name); if (serializedInput != null) { createSubOrchestrationActionBuilder.setInput(StringValue.of(serializedInput)); @@ -521,7 +519,7 @@ public Task callSubOrchestrator( // Add router information for cross-app routing of sub-orchestrations if (hasSourceAppId()) { - OrchestratorService.TaskRouter.Builder routerBuilder = OrchestratorService.TaskRouter.newBuilder() + Orchestration.TaskRouter.Builder routerBuilder = Orchestration.TaskRouter.newBuilder() .setSourceAppID(this.appId); // Add target app ID if specified in options @@ -537,14 +535,14 @@ public Task callSubOrchestrator( TaskFactory taskFactory = () -> { int id = this.sequenceNumber++; - OrchestratorService.OrchestratorAction.Builder actionBuilder = OrchestratorService.OrchestratorAction + OrchestratorActions.OrchestratorAction.Builder actionBuilder = OrchestratorActions.OrchestratorAction .newBuilder() .setId(id) .setCreateSubOrchestration(createSubOrchestrationActionBuilder); // Set router on the OrchestratorAction for cross-app routing if (hasSourceAppId()) { - OrchestratorService.TaskRouter.Builder actionRouterBuilder = OrchestratorService.TaskRouter.newBuilder() + Orchestration.TaskRouter.Builder actionRouterBuilder = Orchestration.TaskRouter.newBuilder() .setSourceAppID(this.appId); if (hasTargetAppId(options)) { actionRouterBuilder.setTargetAppID(options.getAppID()); @@ -592,8 +590,8 @@ public Task waitForExternalEvent(String name, Duration timeout, Class CompletableTask eventTask = new ExternalEventTask<>(name, id, timeout); // Check for a previously received event with the same name - for (OrchestratorService.HistoryEvent e : this.unprocessedEvents) { - OrchestratorService.EventRaisedEvent existing = e.getEventRaised(); + for (HistoryEvents.HistoryEvent e : this.unprocessedEvents) { + HistoryEvents.EventRaisedEvent existing = e.getEventRaised(); if (name.equalsIgnoreCase(existing.getName())) { String rawEventData = existing.getInput().getValue(); V data = this.dataConverter.deserialize(rawEventData, dataType); @@ -635,15 +633,15 @@ public Task waitForExternalEvent(String name, Duration timeout, Class return eventTask; } - private void handleTaskScheduled(OrchestratorService.HistoryEvent e) { + private void handleTaskScheduled(HistoryEvents.HistoryEvent e) { int taskId = e.getEventId(); - OrchestratorService.TaskScheduledEvent taskScheduled = e.getTaskScheduled(); + HistoryEvents.TaskScheduledEvent taskScheduled = e.getTaskScheduled(); // The history shows that this orchestrator created a durable task in a previous execution. // We can therefore remove it from the map of pending actions. If we can't find the pending // action, then we assume a non-deterministic code violation in the orchestrator. - OrchestratorService.OrchestratorAction taskAction = this.pendingActions.remove(taskId); + OrchestratorActions.OrchestratorAction taskAction = this.pendingActions.remove(taskId); if (taskAction == null) { String message = String.format( "Non-deterministic orchestrator detected: a history event scheduling an activity task with sequence " @@ -657,8 +655,8 @@ private void handleTaskScheduled(OrchestratorService.HistoryEvent e) { } @SuppressWarnings("unchecked") - private void handleTaskCompleted(OrchestratorService.HistoryEvent e) { - OrchestratorService.TaskCompletedEvent completedEvent = e.getTaskCompleted(); + private void handleTaskCompleted(HistoryEvents.HistoryEvent e) { + HistoryEvents.TaskCompletedEvent completedEvent = e.getTaskCompleted(); int taskId = completedEvent.getTaskScheduledId(); TaskRecord record = this.openTasks.remove(taskId); if (record == null) { @@ -688,8 +686,8 @@ private void handleTaskCompleted(OrchestratorService.HistoryEvent e) { } } - private void handleTaskFailed(OrchestratorService.HistoryEvent e) { - OrchestratorService.TaskFailedEvent failedEvent = e.getTaskFailed(); + private void handleTaskFailed(HistoryEvents.HistoryEvent e) { + HistoryEvents.TaskFailedEvent failedEvent = e.getTaskFailed(); int taskId = failedEvent.getTaskScheduledId(); TaskRecord record = this.openTasks.remove(taskId); if (record == null) { @@ -712,8 +710,8 @@ private void handleTaskFailed(OrchestratorService.HistoryEvent e) { } @SuppressWarnings("unchecked") - private void handleEventRaised(OrchestratorService.HistoryEvent e) { - OrchestratorService.EventRaisedEvent eventRaised = e.getEventRaised(); + private void handleEventRaised(HistoryEvents.HistoryEvent e) { + HistoryEvents.EventRaisedEvent eventRaised = e.getEventRaised(); String eventName = eventRaised.getName(); Queue> outstandingEventQueue = this.outstandingEvents.get(eventName); @@ -740,17 +738,17 @@ private void handleEventRaised(OrchestratorService.HistoryEvent e) { } } - private void handleEventWhileSuspended(OrchestratorService.HistoryEvent historyEvent) { - if (historyEvent.getEventTypeCase() != OrchestratorService.HistoryEvent.EventTypeCase.EXECUTIONSUSPENDED) { + private void handleEventWhileSuspended(HistoryEvents.HistoryEvent historyEvent) { + if (historyEvent.getEventTypeCase() != HistoryEvents.HistoryEvent.EventTypeCase.EXECUTIONSUSPENDED) { eventsWhileSuspended.offer(historyEvent); } } - private void handleExecutionSuspended(OrchestratorService.HistoryEvent historyEvent) { + private void handleExecutionSuspended(HistoryEvents.HistoryEvent historyEvent) { this.isSuspended = true; } - private void handleExecutionResumed(OrchestratorService.HistoryEvent historyEvent) { + private void handleExecutionResumed(HistoryEvents.HistoryEvent historyEvent) { this.isSuspended = false; while (!eventsWhileSuspended.isEmpty()) { this.processEvent(eventsWhileSuspended.poll()); @@ -799,9 +797,9 @@ private Task createTimer(String name, Instant finalFireAt) { private CompletableTask createInstantTimer(String name, int id, Instant fireAt) { Timestamp ts = DataConverter.getTimestampFromInstant(fireAt); - this.pendingActions.put(id, OrchestratorService.OrchestratorAction.newBuilder() + this.pendingActions.put(id, OrchestratorActions.OrchestratorAction.newBuilder() .setId(id) - .setCreateTimer(OrchestratorService.CreateTimerAction.newBuilder() + .setCreateTimer(OrchestratorActions.CreateTimerAction.newBuilder() .setName(name).setFireAt(ts)) .build()); @@ -815,19 +813,19 @@ private CompletableTask createInstantTimer(String name, int id, Instant fi return timerTask; } - private void handleTimerCreated(OrchestratorService.HistoryEvent e) { + private void handleTimerCreated(HistoryEvents.HistoryEvent e) { int timerEventId = e.getEventId(); if (timerEventId == -100) { // Infrastructure timer used by the dispatcher to break transactions into multiple batches return; } - OrchestratorService.TimerCreatedEvent timerCreatedEvent = e.getTimerCreated(); + HistoryEvents.TimerCreatedEvent timerCreatedEvent = e.getTimerCreated(); // The history shows that this orchestrator created a durable timer in a previous execution. // We can therefore remove it from the map of pending actions. If we can't find the pending // action, then we assume a non-deterministic code violation in the orchestrator. - OrchestratorService.OrchestratorAction timerAction = this.pendingActions.remove(timerEventId); + OrchestratorActions.OrchestratorAction timerAction = this.pendingActions.remove(timerEventId); if (timerAction == null) { String message = String.format( "Non-deterministic orchestrator detected: a history event creating a timer with ID %d and " @@ -840,8 +838,8 @@ private void handleTimerCreated(OrchestratorService.HistoryEvent e) { } } - public void handleTimerFired(OrchestratorService.HistoryEvent e) { - OrchestratorService.TimerFiredEvent timerFiredEvent = e.getTimerFired(); + public void handleTimerFired(HistoryEvents.HistoryEvent e) { + HistoryEvents.TimerFiredEvent timerFiredEvent = e.getTimerFired(); int timerEventId = timerFiredEvent.getTimerId(); TaskRecord record = this.openTasks.remove(timerEventId); if (record == null) { @@ -860,11 +858,11 @@ public void handleTimerFired(OrchestratorService.HistoryEvent e) { task.complete(null); } - private void handleSubOrchestrationCreated(OrchestratorService.HistoryEvent e) { + private void handleSubOrchestrationCreated(HistoryEvents.HistoryEvent e) { int taskId = e.getEventId(); - OrchestratorService.SubOrchestrationInstanceCreatedEvent subOrchestrationInstanceCreated = + HistoryEvents.SubOrchestrationInstanceCreatedEvent subOrchestrationInstanceCreated = e.getSubOrchestrationInstanceCreated(); - OrchestratorService.OrchestratorAction taskAction = this.pendingActions.remove(taskId); + OrchestratorActions.OrchestratorAction taskAction = this.pendingActions.remove(taskId); if (taskAction == null) { String message = String.format( "Non-deterministic orchestrator detected: a history event scheduling an sub-orchestration task " @@ -877,8 +875,8 @@ private void handleSubOrchestrationCreated(OrchestratorService.HistoryEvent e) { } } - private void handleSubOrchestrationCompleted(OrchestratorService.HistoryEvent e) { - OrchestratorService.SubOrchestrationInstanceCompletedEvent subOrchestrationInstanceCompletedEvent = + private void handleSubOrchestrationCompleted(HistoryEvents.HistoryEvent e) { + HistoryEvents.SubOrchestrationInstanceCompletedEvent subOrchestrationInstanceCompletedEvent = e.getSubOrchestrationInstanceCompleted(); int taskId = subOrchestrationInstanceCompletedEvent.getTaskScheduledId(); TaskRecord record = this.openTasks.remove(taskId); @@ -909,8 +907,8 @@ private void handleSubOrchestrationCompleted(OrchestratorService.HistoryEvent e) } } - private void handleSubOrchestrationFailed(OrchestratorService.HistoryEvent e) { - OrchestratorService.SubOrchestrationInstanceFailedEvent subOrchestrationInstanceFailedEvent = + private void handleSubOrchestrationFailed(HistoryEvents.HistoryEvent e) { + HistoryEvents.SubOrchestrationInstanceFailedEvent subOrchestrationInstanceFailedEvent = e.getSubOrchestrationInstanceFailed(); int taskId = subOrchestrationInstanceFailedEvent.getTaskScheduledId(); TaskRecord record = this.openTasks.remove(taskId); @@ -933,29 +931,29 @@ private void handleSubOrchestrationFailed(OrchestratorService.HistoryEvent e) { task.completeExceptionally(exception); } - private void handleExecutionTerminated(OrchestratorService.HistoryEvent e) { - OrchestratorService.ExecutionTerminatedEvent executionTerminatedEvent = e.getExecutionTerminated(); + private void handleExecutionTerminated(HistoryEvents.HistoryEvent e) { + HistoryEvents.ExecutionTerminatedEvent executionTerminatedEvent = e.getExecutionTerminated(); this.completeInternal(executionTerminatedEvent.getInput().getValue(), null, - OrchestratorService.OrchestrationStatus.ORCHESTRATION_STATUS_TERMINATED); + Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_TERMINATED); } @Override public void complete(Object output) { if (this.continuedAsNew) { this.completeInternal(this.continuedAsNewInput, - OrchestratorService.OrchestrationStatus.ORCHESTRATION_STATUS_CONTINUED_AS_NEW); + Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_CONTINUED_AS_NEW); } else { - this.completeInternal(output, OrchestratorService.OrchestrationStatus.ORCHESTRATION_STATUS_COMPLETED); + this.completeInternal(output, Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_COMPLETED); } } public void fail(FailureDetails failureDetails) { // TODO: How does a parent orchestration use the output to construct an exception? this.completeInternal(null, failureDetails, - OrchestratorService.OrchestrationStatus.ORCHESTRATION_STATUS_FAILED); + Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_FAILED); } - private void completeInternal(Object output, OrchestratorService.OrchestrationStatus runtimeStatus) { + private void completeInternal(Object output, Orchestration.OrchestrationStatus runtimeStatus) { String resultAsJson = TaskOrchestrationExecutor.this.dataConverter.serialize(output); this.completeInternal(resultAsJson, null, runtimeStatus); } @@ -963,11 +961,11 @@ private void completeInternal(Object output, OrchestratorService.OrchestrationSt private void completeInternal( @Nullable String rawOutput, @Nullable FailureDetails failureDetails, - OrchestratorService.OrchestrationStatus runtimeStatus) { + Orchestration.OrchestrationStatus runtimeStatus) { Helpers.throwIfOrchestratorComplete(this.isComplete); - OrchestratorService.CompleteOrchestrationAction.Builder builder = OrchestratorService.CompleteOrchestrationAction + OrchestratorActions.CompleteOrchestrationAction.Builder builder = OrchestratorActions.CompleteOrchestrationAction .newBuilder(); builder.setOrchestrationStatus(runtimeStatus); @@ -988,7 +986,7 @@ private void completeInternal( } int id = this.sequenceNumber++; - OrchestratorService.OrchestratorAction.Builder actionBuilder = OrchestratorService.OrchestratorAction + OrchestratorActions.OrchestratorAction.Builder actionBuilder = OrchestratorActions.OrchestratorAction .newBuilder() .setId(id) .setCompleteOrchestration(builder.build()); @@ -996,7 +994,7 @@ private void completeInternal( // Add router to completion action for cross-app routing back to parent if (hasSourceAppId()) { actionBuilder.setRouter( - OrchestratorService.TaskRouter.newBuilder() + Orchestration.TaskRouter.newBuilder() .setSourceAppID(this.appId) .build()); } @@ -1005,19 +1003,19 @@ private void completeInternal( this.isComplete = true; } - private void addCarryoverEvents(OrchestratorService.CompleteOrchestrationAction.Builder builder) { + private void addCarryoverEvents(OrchestratorActions.CompleteOrchestrationAction.Builder builder) { // Add historyEvent in the unprocessedEvents buffer // Add historyEvent in the new event list that haven't been added to the buffer. // We don't check the event in the pass event list to avoid duplicated events. - Set externalEvents = new HashSet<>(this.unprocessedEvents); - List newEvents = this.historyEventPlayer.getNewEvents(); + Set externalEvents = new HashSet<>(this.unprocessedEvents); + List newEvents = this.historyEventPlayer.getNewEvents(); int currentHistoryIndex = this.historyEventPlayer.getCurrentHistoryIndex(); // Only add events that haven't been processed to the carryOverEvents // currentHistoryIndex will point to the first unprocessed event for (int i = currentHistoryIndex; i < newEvents.size(); i++) { - OrchestratorService.HistoryEvent historyEvent = newEvents.get(i); - if (historyEvent.getEventTypeCase() == OrchestratorService.HistoryEvent.EventTypeCase.EVENTRAISED) { + HistoryEvents.HistoryEvent historyEvent = newEvents.get(i); + if (historyEvent.getEventTypeCase() == HistoryEvents.HistoryEvent.EventTypeCase.EVENTRAISED) { externalEvents.add(historyEvent); } } @@ -1033,10 +1031,10 @@ private boolean processNextEvent() { return this.historyEventPlayer.moveNext(); } - private void processEvent(OrchestratorService.HistoryEvent e) { + private void processEvent(HistoryEvents.HistoryEvent e) { boolean overrideSuspension = e.getEventTypeCase() - == OrchestratorService.HistoryEvent.EventTypeCase.EXECUTIONRESUMED - || e.getEventTypeCase() == OrchestratorService.HistoryEvent.EventTypeCase.EXECUTIONTERMINATED; + == HistoryEvents.HistoryEvent.EventTypeCase.EXECUTIONRESUMED + || e.getEventTypeCase() == HistoryEvents.HistoryEvent.EventTypeCase.EXECUTIONTERMINATED; if (this.isSuspended && !overrideSuspension) { this.handleEventWhileSuspended(e); } else { @@ -1060,7 +1058,7 @@ private void processEvent(OrchestratorService.HistoryEvent e) { this.logger.fine(() -> this.instanceId + ": Workflow orchestrator completed"); break; case EXECUTIONSTARTED: - OrchestratorService.ExecutionStartedEvent executionStarted = e.getExecutionStarted(); + HistoryEvents.ExecutionStartedEvent executionStarted = e.getExecutionStarted(); this.setName(executionStarted.getName()); this.setInput(executionStarted.getInput().getValue()); this.setInstanceId(executionStarted.getOrchestrationInstance().getInstanceId()); @@ -1068,7 +1066,7 @@ private void processEvent(OrchestratorService.HistoryEvent e) { // For cross-app suborchestrations, if the router has a target, use that as our appID // since that's where we're actually executing if (e.hasRouter()) { - OrchestratorService.TaskRouter router = e.getRouter(); + Orchestration.TaskRouter router = e.getRouter(); if (router.hasTargetAppID()) { this.setAppId(router.getTargetAppID()); } else { @@ -1151,12 +1149,12 @@ private void processEvent(OrchestratorService.HistoryEvent e) { public void setVersionNotRegistered() { this.pendingActions.clear(); - OrchestratorService.CompleteOrchestrationAction.Builder builder = OrchestratorService.CompleteOrchestrationAction + OrchestratorActions.CompleteOrchestrationAction.Builder builder = OrchestratorActions.CompleteOrchestrationAction .newBuilder(); - builder.setOrchestrationStatus(OrchestratorService.OrchestrationStatus.ORCHESTRATION_STATUS_STALLED); + builder.setOrchestrationStatus(Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_STALLED); int id = this.sequenceNumber++; - OrchestratorService.OrchestratorAction action = OrchestratorService.OrchestratorAction.newBuilder() + OrchestratorActions.OrchestratorAction action = OrchestratorActions.OrchestratorAction.newBuilder() .setId(id) .setCompleteOrchestration(builder.build()) .build(); @@ -1189,14 +1187,14 @@ public Class getDataType() { } private class OrchestrationHistoryIterator { - private final List pastEvents; - private final List newEvents; + private final List pastEvents; + private final List newEvents; - private List currentHistoryList; + private List currentHistoryList; private int currentHistoryIndex; - public OrchestrationHistoryIterator(List pastEvents, - List newEvents) { + public OrchestrationHistoryIterator(List pastEvents, + List newEvents) { this.pastEvents = pastEvents; this.newEvents = newEvents; this.currentHistoryList = pastEvents; @@ -1217,12 +1215,12 @@ public boolean moveNext() { } // Process the next event in the history - OrchestratorService.HistoryEvent next = this.currentHistoryList.get(this.currentHistoryIndex++); + HistoryEvents.HistoryEvent next = this.currentHistoryList.get(this.currentHistoryIndex++); ContextImplTask.this.processEvent(next); return true; } - List getNewEvents() { + List getNewEvents() { return this.newEvents; } diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestratorResult.java b/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestratorResult.java index 9efb0751f2..0e6d21d2ed 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestratorResult.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestratorResult.java @@ -13,7 +13,7 @@ package io.dapr.durabletask; -import io.dapr.durabletask.implementation.protobuf.OrchestratorService; +import io.dapr.durabletask.implementation.protobuf.OrchestratorActions; import java.util.Collection; import java.util.Collections; @@ -21,7 +21,7 @@ public final class TaskOrchestratorResult { - private final Collection actions; + private final Collection actions; private final String customStatus; @@ -37,7 +37,7 @@ public final class TaskOrchestratorResult { * @param version the orchestrator version * @param patches the patches to apply */ - public TaskOrchestratorResult(Collection actions, + public TaskOrchestratorResult(Collection actions, String customStatus, String version, List patches) { this.actions = Collections.unmodifiableCollection(actions); this.customStatus = customStatus; @@ -45,7 +45,7 @@ public TaskOrchestratorResult(Collection this.patches = patches; } - public Collection getActions() { + public Collection getActions() { return this.actions; } diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/runner/ActivityRunner.java b/durabletask-client/src/main/java/io/dapr/durabletask/runner/ActivityRunner.java index c9c0baa434..be134c6778 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/runner/ActivityRunner.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/runner/ActivityRunner.java @@ -16,6 +16,7 @@ import com.google.protobuf.StringValue; import io.dapr.durabletask.FailureDetails; import io.dapr.durabletask.TaskActivityExecutor; +import io.dapr.durabletask.implementation.protobuf.Orchestration; import io.dapr.durabletask.implementation.protobuf.OrchestratorService; import io.dapr.durabletask.implementation.protobuf.TaskHubSidecarServiceGrpc; import io.grpc.StatusRuntimeException; @@ -102,7 +103,7 @@ private void runWithoutTracing() { private void executeActivity() throws Throwable { String output = null; - OrchestratorService.TaskFailureDetails failureDetails = null; + Orchestration.TaskFailureDetails failureDetails = null; Throwable failureException = null; try { output = taskActivityExecutor.execute( @@ -112,7 +113,7 @@ private void executeActivity() throws Throwable { activityRequest.getTaskId(), activityRequest.getParentTraceContext().getTraceParent()); } catch (Throwable e) { - failureDetails = OrchestratorService.TaskFailureDetails.newBuilder() + failureDetails = Orchestration.TaskFailureDetails.newBuilder() .setErrorType(e.getClass().getName()) .setErrorMessage(e.getMessage()) .setStackTrace(StringValue.of(FailureDetails.getFullStackTrace(e))) @@ -151,7 +152,7 @@ private Context extractTraceContext() { return Context.current(); } - OrchestratorService.TraceContext traceContext = activityRequest.getParentTraceContext(); + Orchestration.TraceContext traceContext = activityRequest.getParentTraceContext(); String traceParent = traceContext.getTraceParent(); if (traceParent.isEmpty()) { diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/runner/OrchestratorRunner.java b/durabletask-client/src/main/java/io/dapr/durabletask/runner/OrchestratorRunner.java index 77046fd225..eb7515a040 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/runner/OrchestratorRunner.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/runner/OrchestratorRunner.java @@ -16,6 +16,7 @@ import com.google.protobuf.StringValue; import io.dapr.durabletask.TaskOrchestrationExecutor; import io.dapr.durabletask.TaskOrchestratorResult; +import io.dapr.durabletask.implementation.protobuf.Orchestration; import io.dapr.durabletask.implementation.protobuf.OrchestratorService; import io.dapr.durabletask.implementation.protobuf.TaskHubSidecarServiceGrpc; import io.grpc.StatusRuntimeException; @@ -58,7 +59,7 @@ public void run() { orchestratorRequest.getPastEventsList(), orchestratorRequest.getNewEventsList()); - var versionBuilder = OrchestratorService.OrchestrationVersion.newBuilder(); + var versionBuilder = Orchestration.OrchestrationVersion.newBuilder(); if (StringUtils.isNotEmpty(taskOrchestratorResult.getVersion())) { versionBuilder.setName(taskOrchestratorResult.getVersion()); diff --git a/durabletask-client/src/test/java/io/dapr/durabletask/SubOrchestrationCrossAppTest.java b/durabletask-client/src/test/java/io/dapr/durabletask/SubOrchestrationCrossAppTest.java index 6ddb4e3e13..dc51716eb0 100644 --- a/durabletask-client/src/test/java/io/dapr/durabletask/SubOrchestrationCrossAppTest.java +++ b/durabletask-client/src/test/java/io/dapr/durabletask/SubOrchestrationCrossAppTest.java @@ -15,7 +15,9 @@ import com.google.protobuf.StringValue; import com.google.protobuf.Timestamp; -import io.dapr.durabletask.implementation.protobuf.OrchestratorService; +import io.dapr.durabletask.implementation.protobuf.HistoryEvents; +import io.dapr.durabletask.implementation.protobuf.Orchestration; +import io.dapr.durabletask.implementation.protobuf.OrchestratorActions; import io.dapr.durabletask.orchestration.TaskOrchestrationFactories; import io.dapr.durabletask.orchestration.TaskOrchestrationFactory; import org.junit.jupiter.api.Test; @@ -38,27 +40,27 @@ class SubOrchestrationCrossAppTest { /** * Helper to build an OrchestratorStarted history event. */ - private static OrchestratorService.HistoryEvent orchestratorStarted() { - return OrchestratorService.HistoryEvent.newBuilder() + private static HistoryEvents.HistoryEvent orchestratorStarted() { + return HistoryEvents.HistoryEvent.newBuilder() .setEventId(-1) .setTimestamp(Timestamp.newBuilder().setSeconds(1000).build()) - .setOrchestratorStarted(OrchestratorService.OrchestratorStartedEvent.newBuilder().build()) + .setOrchestratorStarted(HistoryEvents.OrchestratorStartedEvent.newBuilder().build()) .build(); } /** * Helper to build an ExecutionStarted history event with a router. */ - private static OrchestratorService.HistoryEvent executionStarted( - String name, String instanceId, String input, OrchestratorService.TaskRouter router) { - OrchestratorService.ExecutionStartedEvent.Builder esBuilder = OrchestratorService.ExecutionStartedEvent + private static HistoryEvents.HistoryEvent executionStarted( + String name, String instanceId, String input, Orchestration.TaskRouter router) { + HistoryEvents.ExecutionStartedEvent.Builder esBuilder = HistoryEvents.ExecutionStartedEvent .newBuilder() .setName(name) .setOrchestrationInstance( - OrchestratorService.OrchestrationInstance.newBuilder().setInstanceId(instanceId).build()) + Orchestration.OrchestrationInstance.newBuilder().setInstanceId(instanceId).build()) .setInput(StringValue.of(input)); - OrchestratorService.HistoryEvent.Builder builder = OrchestratorService.HistoryEvent.newBuilder() + HistoryEvents.HistoryEvent.Builder builder = HistoryEvents.HistoryEvent.newBuilder() .setEventId(-1) .setTimestamp(Timestamp.newBuilder().setSeconds(1000).build()) .setExecutionStarted(esBuilder.build()); @@ -73,11 +75,11 @@ private static OrchestratorService.HistoryEvent executionStarted( /** * Helper to build an OrchestratorCompleted history event. */ - private static OrchestratorService.HistoryEvent orchestratorCompleted() { - return OrchestratorService.HistoryEvent.newBuilder() + private static HistoryEvents.HistoryEvent orchestratorCompleted() { + return HistoryEvents.HistoryEvent.newBuilder() .setEventId(-1) .setTimestamp(Timestamp.newBuilder().setSeconds(1000).build()) - .setOrchestratorCompleted(OrchestratorService.OrchestratorCompletedEvent.newBuilder().build()) + .setOrchestratorCompleted(HistoryEvents.OrchestratorCompletedEvent.newBuilder().build()) .build(); } @@ -130,11 +132,11 @@ void callSubOrchestrator_withTargetAppId_setsRouterOnAction() { TaskOrchestrationExecutor executor = createExecutor(orchestratorName, orchestration, sourceAppId); - OrchestratorService.TaskRouter router = OrchestratorService.TaskRouter.newBuilder() + Orchestration.TaskRouter router = Orchestration.TaskRouter.newBuilder() .setSourceAppID(sourceAppId) .build(); - List newEvents = List.of( + List newEvents = List.of( orchestratorStarted(), executionStarted(orchestratorName, "parent-instance", "\"hello\"", router), orchestratorCompleted() @@ -143,14 +145,14 @@ void callSubOrchestrator_withTargetAppId_setsRouterOnAction() { TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); // There should be a CreateSubOrchestration action - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertEquals(1, actions.size()); - OrchestratorService.OrchestratorAction action = actions.get(0); + OrchestratorActions.OrchestratorAction action = actions.get(0); assertTrue(action.hasCreateSubOrchestration()); // Verify the CreateSubOrchestrationAction has the router - OrchestratorService.CreateSubOrchestrationAction createSub = action.getCreateSubOrchestration(); + OrchestratorActions.CreateSubOrchestrationAction createSub = action.getCreateSubOrchestration(); assertEquals(subOrchestratorName, createSub.getName()); assertEquals("child-instance-1", createSub.getInstanceId()); assertTrue(createSub.hasRouter()); @@ -178,11 +180,11 @@ void callSubOrchestrator_withoutTargetAppId_setsRouterWithSourceOnly() { TaskOrchestrationExecutor executor = createExecutor(orchestratorName, orchestration, sourceAppId); - OrchestratorService.TaskRouter router = OrchestratorService.TaskRouter.newBuilder() + Orchestration.TaskRouter router = Orchestration.TaskRouter.newBuilder() .setSourceAppID(sourceAppId) .build(); - List newEvents = List.of( + List newEvents = List.of( orchestratorStarted(), executionStarted(orchestratorName, "parent-instance", "\"hello\"", router), orchestratorCompleted() @@ -190,14 +192,14 @@ void callSubOrchestrator_withoutTargetAppId_setsRouterWithSourceOnly() { TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertEquals(1, actions.size()); - OrchestratorService.OrchestratorAction action = actions.get(0); + OrchestratorActions.OrchestratorAction action = actions.get(0); assertTrue(action.hasCreateSubOrchestration()); // Router should have source only, no target - OrchestratorService.CreateSubOrchestrationAction createSub = action.getCreateSubOrchestration(); + OrchestratorActions.CreateSubOrchestrationAction createSub = action.getCreateSubOrchestration(); assertTrue(createSub.hasRouter()); assertEquals(sourceAppId, createSub.getRouter().getSourceAppID()); assertFalse(createSub.getRouter().hasTargetAppID()); @@ -222,7 +224,7 @@ void callSubOrchestrator_withNullAppId_noRouterSet() { TaskOrchestrationExecutor executor = createExecutor(orchestratorName, orchestration, null); // ExecutionStarted without a router - List newEvents = List.of( + List newEvents = List.of( orchestratorStarted(), executionStarted(orchestratorName, "parent-instance", "\"hello\"", null), orchestratorCompleted() @@ -230,14 +232,14 @@ void callSubOrchestrator_withNullAppId_noRouterSet() { TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertEquals(1, actions.size()); - OrchestratorService.OrchestratorAction action = actions.get(0); + OrchestratorActions.OrchestratorAction action = actions.get(0); assertTrue(action.hasCreateSubOrchestration()); // No router should be set when appId is null - OrchestratorService.CreateSubOrchestrationAction createSub = action.getCreateSubOrchestration(); + OrchestratorActions.CreateSubOrchestrationAction createSub = action.getCreateSubOrchestration(); assertFalse(createSub.hasRouter()); assertFalse(action.hasRouter()); } @@ -263,12 +265,12 @@ void executionStarted_withRouterTargetAppId_usesTargetAsAppId() { TaskOrchestrationExecutor executor = createExecutor(orchestratorName, orchestration, sourceAppId); // Router with BOTH source and target (cross-app suborchestration scenario) - OrchestratorService.TaskRouter router = OrchestratorService.TaskRouter.newBuilder() + Orchestration.TaskRouter router = Orchestration.TaskRouter.newBuilder() .setSourceAppID(sourceAppId) .setTargetAppID(targetAppId) .build(); - List newEvents = List.of( + List newEvents = List.of( orchestratorStarted(), executionStarted(orchestratorName, "sub-instance-1", "\"data\"", router), orchestratorCompleted() @@ -294,11 +296,11 @@ void executionStarted_withRouterSourceOnly_usesSourceAsAppId() { TaskOrchestrationExecutor executor = createExecutor(orchestratorName, orchestration, sourceAppId); // Router with source only (normal, single-app scenario) - OrchestratorService.TaskRouter router = OrchestratorService.TaskRouter.newBuilder() + Orchestration.TaskRouter router = Orchestration.TaskRouter.newBuilder() .setSourceAppID(sourceAppId) .build(); - List newEvents = List.of( + List newEvents = List.of( orchestratorStarted(), executionStarted(orchestratorName, "instance-1", "\"data\"", router), orchestratorCompleted() @@ -323,7 +325,7 @@ void executionStarted_withNoRouter_appIdIsNull() { TaskOrchestrationExecutor executor = createExecutor(orchestratorName, orchestration, null); // No router on the event - List newEvents = List.of( + List newEvents = List.of( orchestratorStarted(), executionStarted(orchestratorName, "instance-1", "\"data\"", null), orchestratorCompleted() @@ -351,11 +353,11 @@ void completeOrchestration_withAppId_setsRouterOnCompletionAction() { TaskOrchestrationExecutor executor = createExecutor(orchestratorName, orchestration, appId); - OrchestratorService.TaskRouter router = OrchestratorService.TaskRouter.newBuilder() + Orchestration.TaskRouter router = Orchestration.TaskRouter.newBuilder() .setSourceAppID(appId) .build(); - List newEvents = List.of( + List newEvents = List.of( orchestratorStarted(), executionStarted(orchestratorName, "instance-1", "\"input\"", router), orchestratorCompleted() @@ -363,12 +365,12 @@ void completeOrchestration_withAppId_setsRouterOnCompletionAction() { TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertEquals(1, actions.size()); - OrchestratorService.OrchestratorAction action = actions.get(0); + OrchestratorActions.OrchestratorAction action = actions.get(0); assertTrue(action.hasCompleteOrchestration()); - assertEquals(OrchestratorService.OrchestrationStatus.ORCHESTRATION_STATUS_COMPLETED, + assertEquals(Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_COMPLETED, action.getCompleteOrchestration().getOrchestrationStatus()); // The completion action should have a router with source appId @@ -388,7 +390,7 @@ void completeOrchestration_withNullAppId_noRouterOnCompletionAction() { // Executor with null appId TaskOrchestrationExecutor executor = createExecutor(orchestratorName, orchestration, null); - List newEvents = List.of( + List newEvents = List.of( orchestratorStarted(), executionStarted(orchestratorName, "instance-1", "\"input\"", null), orchestratorCompleted() @@ -396,10 +398,10 @@ void completeOrchestration_withNullAppId_noRouterOnCompletionAction() { TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertEquals(1, actions.size()); - OrchestratorService.OrchestratorAction action = actions.get(0); + OrchestratorActions.OrchestratorAction action = actions.get(0); assertTrue(action.hasCompleteOrchestration()); // No router should be set @@ -420,12 +422,12 @@ void completeOrchestration_crossAppSubOrchestrator_routerHasTargetDerivedAppId() TaskOrchestrationExecutor executor = createExecutor(orchestratorName, orchestration, parentAppId); // Router has both source and target (cross-app suborchestration) - OrchestratorService.TaskRouter router = OrchestratorService.TaskRouter.newBuilder() + Orchestration.TaskRouter router = Orchestration.TaskRouter.newBuilder() .setSourceAppID(parentAppId) .setTargetAppID(targetAppId) .build(); - List newEvents = List.of( + List newEvents = List.of( orchestratorStarted(), executionStarted(orchestratorName, "sub-instance-1", "\"input\"", router), orchestratorCompleted() @@ -433,10 +435,10 @@ void completeOrchestration_crossAppSubOrchestrator_routerHasTargetDerivedAppId() TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertEquals(1, actions.size()); - OrchestratorService.OrchestratorAction action = actions.get(0); + OrchestratorActions.OrchestratorAction action = actions.get(0); assertTrue(action.hasCompleteOrchestration()); // The router source should be the target app (since that's where we're executing) @@ -464,11 +466,11 @@ void crossAppSubOrchestration_fullFlow_routersCorrectlySet() { TaskOrchestrationExecutor executor = createExecutor(orchestratorName, orchestration, sourceAppId); - OrchestratorService.TaskRouter router = OrchestratorService.TaskRouter.newBuilder() + Orchestration.TaskRouter router = Orchestration.TaskRouter.newBuilder() .setSourceAppID(sourceAppId) .build(); - List newEvents = List.of( + List newEvents = List.of( orchestratorStarted(), executionStarted(orchestratorName, "parent-instance", "\"start\"", router), orchestratorCompleted() @@ -476,14 +478,14 @@ void crossAppSubOrchestration_fullFlow_routersCorrectlySet() { TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); // Should have 1 action: CreateSubOrchestration assertEquals(1, actions.size()); - OrchestratorService.OrchestratorAction subAction = actions.get(0); + OrchestratorActions.OrchestratorAction subAction = actions.get(0); assertTrue(subAction.hasCreateSubOrchestration()); - OrchestratorService.CreateSubOrchestrationAction createSub = subAction.getCreateSubOrchestration(); + OrchestratorActions.CreateSubOrchestrationAction createSub = subAction.getCreateSubOrchestration(); assertEquals(subOrchestratorName, createSub.getName()); assertEquals("child-id-1", createSub.getInstanceId()); @@ -510,7 +512,7 @@ void callSubOrchestrator_withEmptyAppId_noRouterSet() { // Executor created with empty appId TaskOrchestrationExecutor executor = createExecutor(orchestratorName, orchestration, ""); - List newEvents = List.of( + List newEvents = List.of( orchestratorStarted(), executionStarted(orchestratorName, "parent-instance", "\"hello\"", null), orchestratorCompleted() @@ -518,10 +520,10 @@ void callSubOrchestrator_withEmptyAppId_noRouterSet() { TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertEquals(1, actions.size()); - OrchestratorService.OrchestratorAction action = actions.get(0); + OrchestratorActions.OrchestratorAction action = actions.get(0); assertTrue(action.hasCreateSubOrchestration()); // No router should be set when appId is empty @@ -547,11 +549,11 @@ void callSubOrchestrator_withRetryPolicyAndAppId_setsRouterAndRetries() { TaskOrchestrationExecutor executor = createExecutor(orchestratorName, orchestration, sourceAppId); - OrchestratorService.TaskRouter router = OrchestratorService.TaskRouter.newBuilder() + Orchestration.TaskRouter router = Orchestration.TaskRouter.newBuilder() .setSourceAppID(sourceAppId) .build(); - List newEvents = List.of( + List newEvents = List.of( orchestratorStarted(), executionStarted(orchestratorName, "parent-instance", "\"hello\"", router), orchestratorCompleted() @@ -561,13 +563,13 @@ void callSubOrchestrator_withRetryPolicyAndAppId_setsRouterAndRetries() { // With RetriableTask the first attempt creates the action; we should still see // the sub-orchestration action with cross-app routing - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertTrue(actions.size() >= 1); - OrchestratorService.OrchestratorAction action = actions.get(0); + OrchestratorActions.OrchestratorAction action = actions.get(0); assertTrue(action.hasCreateSubOrchestration()); - OrchestratorService.CreateSubOrchestrationAction createSub = action.getCreateSubOrchestration(); + OrchestratorActions.CreateSubOrchestrationAction createSub = action.getCreateSubOrchestration(); assertTrue(createSub.hasRouter()); assertEquals(sourceAppId, createSub.getRouter().getSourceAppID()); assertEquals(targetAppId, createSub.getRouter().getTargetAppID()); diff --git a/pom.xml b/pom.xml index 910570b362..fe3bd5cd23 100644 --- a/pom.xml +++ b/pom.xml @@ -17,7 +17,7 @@ 1.79.0 3.25.5 https://raw.githubusercontent.com/dapr/dapr/v1.17.0/dapr/proto - https://raw.githubusercontent.com/dapr/durabletask-protobuf/main/protos/orchestrator_service.proto + https://raw.githubusercontent.com/dapr/durabletask-protobuf/main/protos 1.18.0-SNAPSHOT 1.7.1 3.8.1 From 53e8c323bf88ce6d18eda688079d24c2f91b75d2 Mon Sep 17 00:00:00 2001 From: Cassie Coyle Date: Thu, 26 Mar 2026 10:00:10 -0500 Subject: [PATCH 07/27] Create the release + release notes automatically (#1689) * create the release + release notes automatically Signed-off-by: Cassandra Coyle * Apply suggestions from code review Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Signed-off-by: Cassie Coyle * pr feedback Signed-off-by: Cassandra Coyle --------- Signed-off-by: Cassandra Coyle Signed-off-by: Cassie Coyle Co-authored-by: Javier Aliaga Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- .github/workflows/create-release.yml | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/.github/workflows/create-release.yml b/.github/workflows/create-release.yml index 397aea3528..af55da253b 100644 --- a/.github/workflows/create-release.yml +++ b/.github/workflows/create-release.yml @@ -53,4 +53,18 @@ jobs: git remote set-url origin https://x-access-token:${{ secrets.DAPR_BOT_TOKEN }}@github.com/${GITHUB_REPOSITORY}.git # Copy first to allow automation to use the latest version and not the release branch's version. cp -R ./.github/scripts ${RUNNER_TEMP}/ - ${RUNNER_TEMP}/scripts/create-release.sh ${{ inputs.rel_version }} \ No newline at end of file + ${RUNNER_TEMP}/scripts/create-release.sh ${{ inputs.rel_version }} + - name: Create GitHub Release with auto-generated notes + if: ${{ !endsWith(inputs.rel_version, '-SNAPSHOT') && !contains(inputs.rel_version, '-rc-') }} + env: + GITHUB_TOKEN: ${{ secrets.DAPR_BOT_TOKEN }} + REL_VERSION: ${{ inputs.rel_version }} + run: | + # Normalize release version by stripping an optional leading 'v' + REL_VERSION="${REL_VERSION#v}" + TAG="v${REL_VERSION}" + if gh release view "${TAG}" >/dev/null 2>&1; then + echo "Release ${TAG} already exists, skipping creation." + else + gh release create "${TAG}" --generate-notes + fi \ No newline at end of file From dd888870afcd1319dd3cc0f0b970776039b9a146 Mon Sep 17 00:00:00 2001 From: Javier Aliaga Date: Thu, 26 Mar 2026 19:45:41 +0100 Subject: [PATCH 08/27] =?UTF-8?q?fix:=20adapt=20to=20Orchestration?= =?UTF-8?q?=E2=86=92Workflow=20proto=20renames=20(durabletask-protobuf#33)?= =?UTF-8?q?=20(#1704)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Update Java type references to match the Workflow terminology rename in dapr/durabletask-protobuf#33. Point proto base URL to JoshVanL's fix-named-reserved branch (durabletask-protobuf#36) which fixes the mixed reserved syntax incompatible with protoc 3.x, and remove the antrun workaround. Signed-off-by: Javier Aliaga --- .../durabletask/DurableTaskGrpcWorker.java | 6 +- .../durabletask/OrchestrationMetadata.java | 8 +- .../dapr/durabletask/OrchestrationRunner.java | 6 +- .../TaskOrchestrationExecutor.java | 74 +++++++++--------- .../durabletask/TaskOrchestratorResult.java | 6 +- .../durabletask/runner/ActivityRunner.java | 4 +- .../runner/OrchestratorRunner.java | 8 +- .../SubOrchestrationCrossAppTest.java | 76 +++++++++---------- 8 files changed, 94 insertions(+), 94 deletions(-) diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/DurableTaskGrpcWorker.java b/durabletask-client/src/main/java/io/dapr/durabletask/DurableTaskGrpcWorker.java index cf3a578690..12f89bd727 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/DurableTaskGrpcWorker.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/DurableTaskGrpcWorker.java @@ -180,8 +180,8 @@ public void startAndBlock() { OrchestratorService.WorkItem workItem = workItemStream.next(); OrchestratorService.WorkItem.RequestCase requestType = workItem.getRequestCase(); - if (requestType == OrchestratorService.WorkItem.RequestCase.ORCHESTRATORREQUEST) { - OrchestratorService.OrchestratorRequest orchestratorRequest = workItem.getOrchestratorRequest(); + if (requestType == OrchestratorService.WorkItem.RequestCase.WORKFLOWREQUEST) { + OrchestratorService.WorkflowRequest orchestratorRequest = workItem.getWorkflowRequest(); logger.log(Level.FINEST, String.format("Processing orchestrator request for instance: {0}", orchestratorRequest.getInstanceId())); @@ -193,7 +193,7 @@ public void startAndBlock() { logger.log(Level.INFO, String.format("Processing activity request: %s for instance: %s, gRPC thread context: %s", activityRequest.getName(), - activityRequest.getOrchestrationInstance().getInstanceId(), + activityRequest.getWorkflowInstance().getInstanceId(), Context.current())); this.workerPool.submit(new ActivityRunner(workItem, taskActivityExecutor, sidecarClient, tracer)); diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationMetadata.java b/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationMetadata.java index 13b0fdcd1b..477b319959 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationMetadata.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationMetadata.java @@ -13,7 +13,7 @@ package io.dapr.durabletask; -import io.dapr.durabletask.implementation.protobuf.Orchestration.OrchestrationState; +import io.dapr.durabletask.implementation.protobuf.Orchestration.WorkflowState; import io.dapr.durabletask.implementation.protobuf.OrchestratorService; import java.time.Instant; @@ -45,11 +45,11 @@ public final class OrchestrationMetadata { OrchestratorService.GetInstanceResponse fetchResponse, DataConverter dataConverter, boolean requestedInputsAndOutputs) { - this(fetchResponse.getOrchestrationState(), dataConverter, requestedInputsAndOutputs); + this(fetchResponse.getWorkflowState(), dataConverter, requestedInputsAndOutputs); } OrchestrationMetadata( - OrchestrationState state, + WorkflowState state, DataConverter dataConverter, boolean requestedInputsAndOutputs) { this.dataConverter = dataConverter; @@ -57,7 +57,7 @@ public final class OrchestrationMetadata { this.name = state.getName(); this.instanceId = state.getInstanceId(); - this.runtimeStatus = OrchestrationRuntimeStatus.fromProtobuf(state.getOrchestrationStatus()); + this.runtimeStatus = OrchestrationRuntimeStatus.fromProtobuf(state.getWorkflowStatus()); this.createdAt = DataConverter.getInstantFromTimestamp(state.getCreatedTimestamp()); this.lastUpdatedAt = DataConverter.getInstantFromTimestamp(state.getLastUpdatedTimestamp()); this.serializedInput = state.getInput().getValue(); diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationRunner.java b/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationRunner.java index bbb9814a86..fe31b1fd33 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationRunner.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/OrchestrationRunner.java @@ -127,9 +127,9 @@ public static byte[] loadAndRun(byte[] orchestratorRequestBytes, TaskOrchestrati throw new IllegalArgumentException("orchestration must not be null"); } - OrchestratorService.OrchestratorRequest orchestratorRequest; + OrchestratorService.WorkflowRequest orchestratorRequest; try { - orchestratorRequest = OrchestratorService.OrchestratorRequest.parseFrom(orchestratorRequestBytes); + orchestratorRequest = OrchestratorService.WorkflowRequest.parseFrom(orchestratorRequestBytes); } catch (InvalidProtocolBufferException e) { throw new IllegalArgumentException("triggerStateProtoBytes was not valid protobuf", e); } @@ -170,7 +170,7 @@ public Boolean isLatestVersion() { orchestratorRequest.getPastEventsList(), orchestratorRequest.getNewEventsList()); - OrchestratorService.OrchestratorResponse response = OrchestratorService.OrchestratorResponse.newBuilder() + OrchestratorService.WorkflowResponse response = OrchestratorService.WorkflowResponse.newBuilder() .setInstanceId(orchestratorRequest.getInstanceId()) .addAllActions(taskOrchestratorResult.getActions()) .setCustomStatus(StringValue.of(taskOrchestratorResult.getCustomStatus())) diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestrationExecutor.java b/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestrationExecutor.java index 2cf29a61dd..185a564509 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestrationExecutor.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestrationExecutor.java @@ -142,7 +142,7 @@ private class ContextImplTask implements TaskOrchestrationContext { private String appId; // LinkedHashMap to maintain insertion order when returning the list of pending actions - private final Map pendingActions = new LinkedHashMap<>(); + private final Map pendingActions = new LinkedHashMap<>(); private final Map> openTasks = new HashMap<>(); private final Map>> outstandingEvents = new LinkedHashMap<>(); private final List unprocessedEvents = new LinkedList<>(); @@ -368,7 +368,7 @@ public Task callActivity( TaskFactory taskFactory = () -> { int id = this.sequenceNumber++; - OrchestratorActions.OrchestratorAction.Builder actionBuilder = OrchestratorActions.OrchestratorAction + OrchestratorActions.WorkflowAction.Builder actionBuilder = OrchestratorActions.WorkflowAction .newBuilder() .setId(id) .setScheduleTask(scheduleTaskBuilder); @@ -463,8 +463,8 @@ public void sendEvent(String instanceId, String eventName, Object eventData) { int id = this.sequenceNumber++; String serializedEventData = this.dataConverter.serialize(eventData); - Orchestration.OrchestrationInstance.Builder orchestrationInstanceBuilder = - Orchestration.OrchestrationInstance.newBuilder() + Orchestration.WorkflowInstance.Builder orchestrationInstanceBuilder = + Orchestration.WorkflowInstance.newBuilder() .setInstanceId(instanceId); OrchestratorActions.SendEventAction.Builder builder = OrchestratorActions .SendEventAction.newBuilder().setInstance(orchestrationInstanceBuilder) @@ -472,7 +472,7 @@ public void sendEvent(String instanceId, String eventName, Object eventData) { if (serializedEventData != null) { builder.setData(StringValue.of(serializedEventData)); } - OrchestratorActions.OrchestratorAction.Builder actionBuilder = OrchestratorActions.OrchestratorAction.newBuilder() + OrchestratorActions.WorkflowAction.Builder actionBuilder = OrchestratorActions.WorkflowAction.newBuilder() .setId(id) .setSendEvent(builder); @@ -505,8 +505,8 @@ public Task callSubOrchestrator( } String serializedInput = this.dataConverter.serialize(input); - OrchestratorActions.CreateSubOrchestrationAction.Builder createSubOrchestrationActionBuilder = - OrchestratorActions.CreateSubOrchestrationAction + OrchestratorActions.CreateChildWorkflowAction.Builder createSubOrchestrationActionBuilder = + OrchestratorActions.CreateChildWorkflowAction .newBuilder().setName(name); if (serializedInput != null) { createSubOrchestrationActionBuilder.setInput(StringValue.of(serializedInput)); @@ -535,10 +535,10 @@ public Task callSubOrchestrator( TaskFactory taskFactory = () -> { int id = this.sequenceNumber++; - OrchestratorActions.OrchestratorAction.Builder actionBuilder = OrchestratorActions.OrchestratorAction + OrchestratorActions.WorkflowAction.Builder actionBuilder = OrchestratorActions.WorkflowAction .newBuilder() .setId(id) - .setCreateSubOrchestration(createSubOrchestrationActionBuilder); + .setCreateChildWorkflow(createSubOrchestrationActionBuilder); // Set router on the OrchestratorAction for cross-app routing if (hasSourceAppId()) { @@ -641,7 +641,7 @@ private void handleTaskScheduled(HistoryEvents.HistoryEvent e) { // The history shows that this orchestrator created a durable task in a previous execution. // We can therefore remove it from the map of pending actions. If we can't find the pending // action, then we assume a non-deterministic code violation in the orchestrator. - OrchestratorActions.OrchestratorAction taskAction = this.pendingActions.remove(taskId); + OrchestratorActions.WorkflowAction taskAction = this.pendingActions.remove(taskId); if (taskAction == null) { String message = String.format( "Non-deterministic orchestrator detected: a history event scheduling an activity task with sequence " @@ -797,7 +797,7 @@ private Task createTimer(String name, Instant finalFireAt) { private CompletableTask createInstantTimer(String name, int id, Instant fireAt) { Timestamp ts = DataConverter.getTimestampFromInstant(fireAt); - this.pendingActions.put(id, OrchestratorActions.OrchestratorAction.newBuilder() + this.pendingActions.put(id, OrchestratorActions.WorkflowAction.newBuilder() .setId(id) .setCreateTimer(OrchestratorActions.CreateTimerAction.newBuilder() .setName(name).setFireAt(ts)) @@ -825,7 +825,7 @@ private void handleTimerCreated(HistoryEvents.HistoryEvent e) { // The history shows that this orchestrator created a durable timer in a previous execution. // We can therefore remove it from the map of pending actions. If we can't find the pending // action, then we assume a non-deterministic code violation in the orchestrator. - OrchestratorActions.OrchestratorAction timerAction = this.pendingActions.remove(timerEventId); + OrchestratorActions.WorkflowAction timerAction = this.pendingActions.remove(timerEventId); if (timerAction == null) { String message = String.format( "Non-deterministic orchestrator detected: a history event creating a timer with ID %d and " @@ -860,9 +860,9 @@ public void handleTimerFired(HistoryEvents.HistoryEvent e) { private void handleSubOrchestrationCreated(HistoryEvents.HistoryEvent e) { int taskId = e.getEventId(); - HistoryEvents.SubOrchestrationInstanceCreatedEvent subOrchestrationInstanceCreated = - e.getSubOrchestrationInstanceCreated(); - OrchestratorActions.OrchestratorAction taskAction = this.pendingActions.remove(taskId); + HistoryEvents.ChildWorkflowInstanceCreatedEvent subOrchestrationInstanceCreated = + e.getChildWorkflowInstanceCreated(); + OrchestratorActions.WorkflowAction taskAction = this.pendingActions.remove(taskId); if (taskAction == null) { String message = String.format( "Non-deterministic orchestrator detected: a history event scheduling an sub-orchestration task " @@ -876,8 +876,8 @@ private void handleSubOrchestrationCreated(HistoryEvents.HistoryEvent e) { } private void handleSubOrchestrationCompleted(HistoryEvents.HistoryEvent e) { - HistoryEvents.SubOrchestrationInstanceCompletedEvent subOrchestrationInstanceCompletedEvent = - e.getSubOrchestrationInstanceCompleted(); + HistoryEvents.ChildWorkflowInstanceCompletedEvent subOrchestrationInstanceCompletedEvent = + e.getChildWorkflowInstanceCompleted(); int taskId = subOrchestrationInstanceCompletedEvent.getTaskScheduledId(); TaskRecord record = this.openTasks.remove(taskId); if (record == null) { @@ -908,8 +908,8 @@ private void handleSubOrchestrationCompleted(HistoryEvents.HistoryEvent e) { } private void handleSubOrchestrationFailed(HistoryEvents.HistoryEvent e) { - HistoryEvents.SubOrchestrationInstanceFailedEvent subOrchestrationInstanceFailedEvent = - e.getSubOrchestrationInstanceFailed(); + HistoryEvents.ChildWorkflowInstanceFailedEvent subOrchestrationInstanceFailedEvent = + e.getChildWorkflowInstanceFailed(); int taskId = subOrchestrationInstanceFailedEvent.getTaskScheduledId(); TaskRecord record = this.openTasks.remove(taskId); if (record == null) { @@ -965,9 +965,9 @@ private void completeInternal( Helpers.throwIfOrchestratorComplete(this.isComplete); - OrchestratorActions.CompleteOrchestrationAction.Builder builder = OrchestratorActions.CompleteOrchestrationAction + OrchestratorActions.CompleteWorkflowAction.Builder builder = OrchestratorActions.CompleteWorkflowAction .newBuilder(); - builder.setOrchestrationStatus(runtimeStatus); + builder.setWorkflowStatus(runtimeStatus); if (rawOutput != null) { builder.setResult(StringValue.of(rawOutput)); @@ -986,10 +986,10 @@ private void completeInternal( } int id = this.sequenceNumber++; - OrchestratorActions.OrchestratorAction.Builder actionBuilder = OrchestratorActions.OrchestratorAction + OrchestratorActions.WorkflowAction.Builder actionBuilder = OrchestratorActions.WorkflowAction .newBuilder() .setId(id) - .setCompleteOrchestration(builder.build()); + .setCompleteWorkflow(builder.build()); // Add router to completion action for cross-app routing back to parent if (hasSourceAppId()) { @@ -1003,7 +1003,7 @@ private void completeInternal( this.isComplete = true; } - private void addCarryoverEvents(OrchestratorActions.CompleteOrchestrationAction.Builder builder) { + private void addCarryoverEvents(OrchestratorActions.CompleteWorkflowAction.Builder builder) { // Add historyEvent in the unprocessedEvents buffer // Add historyEvent in the new event list that haven't been added to the buffer. // We don't check the event in the pass event list to avoid duplicated events. @@ -1040,20 +1040,20 @@ private void processEvent(HistoryEvents.HistoryEvent e) { } else { this.logger.fine(() -> this.instanceId + ": Processing event: " + e.getEventTypeCase()); switch (e.getEventTypeCase()) { - case ORCHESTRATORSTARTED: + case WORKFLOWSTARTED: Instant instant = DataConverter.getInstantFromTimestamp(e.getTimestamp()); this.setCurrentInstant(instant); - if (StringUtils.isNotEmpty(e.getOrchestratorStarted().getVersion().getName())) { - this.orchestratorVersionName = e.getOrchestratorStarted().getVersion().getName(); + if (StringUtils.isNotEmpty(e.getWorkflowStarted().getVersion().getName())) { + this.orchestratorVersionName = e.getWorkflowStarted().getVersion().getName(); } - for (var patch : e.getOrchestratorStarted().getVersion().getPatchesList()) { + for (var patch : e.getWorkflowStarted().getVersion().getPatchesList()) { this.historyPatches.put(patch, true); } this.logger.fine(() -> this.instanceId + ": Workflow orchestrator started"); break; - case ORCHESTRATORCOMPLETED: + case WORKFLOWCOMPLETED: // No action needed this.logger.fine(() -> this.instanceId + ": Workflow orchestrator completed"); break; @@ -1061,7 +1061,7 @@ private void processEvent(HistoryEvents.HistoryEvent e) { HistoryEvents.ExecutionStartedEvent executionStarted = e.getExecutionStarted(); this.setName(executionStarted.getName()); this.setInput(executionStarted.getInput().getValue()); - this.setInstanceId(executionStarted.getOrchestrationInstance().getInstanceId()); + this.setInstanceId(executionStarted.getWorkflowInstance().getInstanceId()); this.logger.fine(() -> this.instanceId + ": Workflow execution started"); // For cross-app suborchestrations, if the router has a target, use that as our appID // since that's where we're actually executing @@ -1122,13 +1122,13 @@ private void processEvent(HistoryEvents.HistoryEvent e) { case TIMERFIRED: this.handleTimerFired(e); break; - case SUBORCHESTRATIONINSTANCECREATED: + case CHILDWORKFLOWINSTANCECREATED: this.handleSubOrchestrationCreated(e); break; - case SUBORCHESTRATIONINSTANCECOMPLETED: + case CHILDWORKFLOWINSTANCECOMPLETED: this.handleSubOrchestrationCompleted(e); break; - case SUBORCHESTRATIONINSTANCEFAILED: + case CHILDWORKFLOWINSTANCEFAILED: this.handleSubOrchestrationFailed(e); break; case EVENTRAISED: @@ -1149,14 +1149,14 @@ private void processEvent(HistoryEvents.HistoryEvent e) { public void setVersionNotRegistered() { this.pendingActions.clear(); - OrchestratorActions.CompleteOrchestrationAction.Builder builder = OrchestratorActions.CompleteOrchestrationAction + OrchestratorActions.CompleteWorkflowAction.Builder builder = OrchestratorActions.CompleteWorkflowAction .newBuilder(); - builder.setOrchestrationStatus(Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_STALLED); + builder.setWorkflowStatus(Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_STALLED); int id = this.sequenceNumber++; - OrchestratorActions.OrchestratorAction action = OrchestratorActions.OrchestratorAction.newBuilder() + OrchestratorActions.WorkflowAction action = OrchestratorActions.WorkflowAction.newBuilder() .setId(id) - .setCompleteOrchestration(builder.build()) + .setCompleteWorkflow(builder.build()) .build(); this.pendingActions.put(id, action); diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestratorResult.java b/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestratorResult.java index 0e6d21d2ed..35ea8b2f32 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestratorResult.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/TaskOrchestratorResult.java @@ -21,7 +21,7 @@ public final class TaskOrchestratorResult { - private final Collection actions; + private final Collection actions; private final String customStatus; @@ -37,7 +37,7 @@ public final class TaskOrchestratorResult { * @param version the orchestrator version * @param patches the patches to apply */ - public TaskOrchestratorResult(Collection actions, + public TaskOrchestratorResult(Collection actions, String customStatus, String version, List patches) { this.actions = Collections.unmodifiableCollection(actions); this.customStatus = customStatus; @@ -45,7 +45,7 @@ public TaskOrchestratorResult(Collection this.patches = patches; } - public Collection getActions() { + public Collection getActions() { return this.actions; } diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/runner/ActivityRunner.java b/durabletask-client/src/main/java/io/dapr/durabletask/runner/ActivityRunner.java index be134c6778..54407edd04 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/runner/ActivityRunner.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/runner/ActivityRunner.java @@ -77,7 +77,7 @@ private void runWithTracing() { .setParent(parentContext) .setSpanKind(SpanKind.INTERNAL) .setAttribute("durabletask.task.instance_id", - activityRequest.getOrchestrationInstance().getInstanceId()) + activityRequest.getWorkflowInstance().getInstanceId()) .setAttribute("durabletask.task.id", activityRequest.getTaskId()) .setAttribute("durabletask.activity.name", activityRequest.getName()) .startSpan(); @@ -123,7 +123,7 @@ private void executeActivity() throws Throwable { OrchestratorService.ActivityResponse.Builder responseBuilder = OrchestratorService.ActivityResponse .newBuilder() - .setInstanceId(activityRequest.getOrchestrationInstance().getInstanceId()) + .setInstanceId(activityRequest.getWorkflowInstance().getInstanceId()) .setTaskId(activityRequest.getTaskId()) .setCompletionToken(workItem.getCompletionToken()); diff --git a/durabletask-client/src/main/java/io/dapr/durabletask/runner/OrchestratorRunner.java b/durabletask-client/src/main/java/io/dapr/durabletask/runner/OrchestratorRunner.java index eb7515a040..f98bb50522 100644 --- a/durabletask-client/src/main/java/io/dapr/durabletask/runner/OrchestratorRunner.java +++ b/durabletask-client/src/main/java/io/dapr/durabletask/runner/OrchestratorRunner.java @@ -31,7 +31,7 @@ public class OrchestratorRunner extends DurableRunner { private static final Logger logger = Logger.getLogger(OrchestratorRunner.class.getPackage().getName()); - private final OrchestratorService.OrchestratorRequest orchestratorRequest; + private final OrchestratorService.WorkflowRequest orchestratorRequest; private final TaskOrchestrationExecutor taskOrchestrationExecutor; /** @@ -49,7 +49,7 @@ public OrchestratorRunner( @Nullable Tracer tracer) { super(workItem, sidecarClient, tracer); - this.orchestratorRequest = workItem.getOrchestratorRequest(); + this.orchestratorRequest = workItem.getWorkflowRequest(); this.taskOrchestrationExecutor = taskOrchestrationExecutor; } @@ -59,7 +59,7 @@ public void run() { orchestratorRequest.getPastEventsList(), orchestratorRequest.getNewEventsList()); - var versionBuilder = Orchestration.OrchestrationVersion.newBuilder(); + var versionBuilder = Orchestration.WorkflowVersion.newBuilder(); if (StringUtils.isNotEmpty(taskOrchestratorResult.getVersion())) { versionBuilder.setName(taskOrchestratorResult.getVersion()); @@ -69,7 +69,7 @@ public void run() { versionBuilder.addAllPatches(taskOrchestratorResult.getPatches()); } - OrchestratorService.OrchestratorResponse response = OrchestratorService.OrchestratorResponse.newBuilder() + OrchestratorService.WorkflowResponse response = OrchestratorService.WorkflowResponse.newBuilder() .setInstanceId(orchestratorRequest.getInstanceId()) .addAllActions(taskOrchestratorResult.getActions()) .setCustomStatus(StringValue.of(taskOrchestratorResult.getCustomStatus())) diff --git a/durabletask-client/src/test/java/io/dapr/durabletask/SubOrchestrationCrossAppTest.java b/durabletask-client/src/test/java/io/dapr/durabletask/SubOrchestrationCrossAppTest.java index dc51716eb0..9ed6bb47e7 100644 --- a/durabletask-client/src/test/java/io/dapr/durabletask/SubOrchestrationCrossAppTest.java +++ b/durabletask-client/src/test/java/io/dapr/durabletask/SubOrchestrationCrossAppTest.java @@ -44,7 +44,7 @@ private static HistoryEvents.HistoryEvent orchestratorStarted() { return HistoryEvents.HistoryEvent.newBuilder() .setEventId(-1) .setTimestamp(Timestamp.newBuilder().setSeconds(1000).build()) - .setOrchestratorStarted(HistoryEvents.OrchestratorStartedEvent.newBuilder().build()) + .setWorkflowStarted(HistoryEvents.WorkflowStartedEvent.newBuilder().build()) .build(); } @@ -56,8 +56,8 @@ private static HistoryEvents.HistoryEvent executionStarted( HistoryEvents.ExecutionStartedEvent.Builder esBuilder = HistoryEvents.ExecutionStartedEvent .newBuilder() .setName(name) - .setOrchestrationInstance( - Orchestration.OrchestrationInstance.newBuilder().setInstanceId(instanceId).build()) + .setWorkflowInstance( + Orchestration.WorkflowInstance.newBuilder().setInstanceId(instanceId).build()) .setInput(StringValue.of(input)); HistoryEvents.HistoryEvent.Builder builder = HistoryEvents.HistoryEvent.newBuilder() @@ -79,7 +79,7 @@ private static HistoryEvents.HistoryEvent orchestratorCompleted() { return HistoryEvents.HistoryEvent.newBuilder() .setEventId(-1) .setTimestamp(Timestamp.newBuilder().setSeconds(1000).build()) - .setOrchestratorCompleted(HistoryEvents.OrchestratorCompletedEvent.newBuilder().build()) + .setWorkflowCompleted(HistoryEvents.WorkflowCompletedEvent.newBuilder().build()) .build(); } @@ -145,14 +145,14 @@ void callSubOrchestrator_withTargetAppId_setsRouterOnAction() { TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); // There should be a CreateSubOrchestration action - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertEquals(1, actions.size()); - OrchestratorActions.OrchestratorAction action = actions.get(0); - assertTrue(action.hasCreateSubOrchestration()); + OrchestratorActions.WorkflowAction action = actions.get(0); + assertTrue(action.hasCreateChildWorkflow()); // Verify the CreateSubOrchestrationAction has the router - OrchestratorActions.CreateSubOrchestrationAction createSub = action.getCreateSubOrchestration(); + OrchestratorActions.CreateChildWorkflowAction createSub = action.getCreateChildWorkflow(); assertEquals(subOrchestratorName, createSub.getName()); assertEquals("child-instance-1", createSub.getInstanceId()); assertTrue(createSub.hasRouter()); @@ -192,14 +192,14 @@ void callSubOrchestrator_withoutTargetAppId_setsRouterWithSourceOnly() { TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertEquals(1, actions.size()); - OrchestratorActions.OrchestratorAction action = actions.get(0); - assertTrue(action.hasCreateSubOrchestration()); + OrchestratorActions.WorkflowAction action = actions.get(0); + assertTrue(action.hasCreateChildWorkflow()); // Router should have source only, no target - OrchestratorActions.CreateSubOrchestrationAction createSub = action.getCreateSubOrchestration(); + OrchestratorActions.CreateChildWorkflowAction createSub = action.getCreateChildWorkflow(); assertTrue(createSub.hasRouter()); assertEquals(sourceAppId, createSub.getRouter().getSourceAppID()); assertFalse(createSub.getRouter().hasTargetAppID()); @@ -232,14 +232,14 @@ void callSubOrchestrator_withNullAppId_noRouterSet() { TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertEquals(1, actions.size()); - OrchestratorActions.OrchestratorAction action = actions.get(0); - assertTrue(action.hasCreateSubOrchestration()); + OrchestratorActions.WorkflowAction action = actions.get(0); + assertTrue(action.hasCreateChildWorkflow()); // No router should be set when appId is null - OrchestratorActions.CreateSubOrchestrationAction createSub = action.getCreateSubOrchestration(); + OrchestratorActions.CreateChildWorkflowAction createSub = action.getCreateChildWorkflow(); assertFalse(createSub.hasRouter()); assertFalse(action.hasRouter()); } @@ -365,13 +365,13 @@ void completeOrchestration_withAppId_setsRouterOnCompletionAction() { TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertEquals(1, actions.size()); - OrchestratorActions.OrchestratorAction action = actions.get(0); - assertTrue(action.hasCompleteOrchestration()); + OrchestratorActions.WorkflowAction action = actions.get(0); + assertTrue(action.hasCompleteWorkflow()); assertEquals(Orchestration.OrchestrationStatus.ORCHESTRATION_STATUS_COMPLETED, - action.getCompleteOrchestration().getOrchestrationStatus()); + action.getCompleteWorkflow().getWorkflowStatus()); // The completion action should have a router with source appId assertTrue(action.hasRouter()); @@ -398,11 +398,11 @@ void completeOrchestration_withNullAppId_noRouterOnCompletionAction() { TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertEquals(1, actions.size()); - OrchestratorActions.OrchestratorAction action = actions.get(0); - assertTrue(action.hasCompleteOrchestration()); + OrchestratorActions.WorkflowAction action = actions.get(0); + assertTrue(action.hasCompleteWorkflow()); // No router should be set assertFalse(action.hasRouter()); @@ -435,11 +435,11 @@ void completeOrchestration_crossAppSubOrchestrator_routerHasTargetDerivedAppId() TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertEquals(1, actions.size()); - OrchestratorActions.OrchestratorAction action = actions.get(0); - assertTrue(action.hasCompleteOrchestration()); + OrchestratorActions.WorkflowAction action = actions.get(0); + assertTrue(action.hasCompleteWorkflow()); // The router source should be the target app (since that's where we're executing) assertTrue(action.hasRouter()); @@ -478,14 +478,14 @@ void crossAppSubOrchestration_fullFlow_routersCorrectlySet() { TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); // Should have 1 action: CreateSubOrchestration assertEquals(1, actions.size()); - OrchestratorActions.OrchestratorAction subAction = actions.get(0); - assertTrue(subAction.hasCreateSubOrchestration()); + OrchestratorActions.WorkflowAction subAction = actions.get(0); + assertTrue(subAction.hasCreateChildWorkflow()); - OrchestratorActions.CreateSubOrchestrationAction createSub = subAction.getCreateSubOrchestration(); + OrchestratorActions.CreateChildWorkflowAction createSub = subAction.getCreateChildWorkflow(); assertEquals(subOrchestratorName, createSub.getName()); assertEquals("child-id-1", createSub.getInstanceId()); @@ -520,14 +520,14 @@ void callSubOrchestrator_withEmptyAppId_noRouterSet() { TaskOrchestratorResult result = executor.execute(new ArrayList<>(), newEvents); - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertEquals(1, actions.size()); - OrchestratorActions.OrchestratorAction action = actions.get(0); - assertTrue(action.hasCreateSubOrchestration()); + OrchestratorActions.WorkflowAction action = actions.get(0); + assertTrue(action.hasCreateChildWorkflow()); // No router should be set when appId is empty - assertFalse(action.getCreateSubOrchestration().hasRouter()); + assertFalse(action.getCreateChildWorkflow().hasRouter()); assertFalse(action.hasRouter()); } @@ -563,13 +563,13 @@ void callSubOrchestrator_withRetryPolicyAndAppId_setsRouterAndRetries() { // With RetriableTask the first attempt creates the action; we should still see // the sub-orchestration action with cross-app routing - List actions = new ArrayList<>(result.getActions()); + List actions = new ArrayList<>(result.getActions()); assertTrue(actions.size() >= 1); - OrchestratorActions.OrchestratorAction action = actions.get(0); - assertTrue(action.hasCreateSubOrchestration()); + OrchestratorActions.WorkflowAction action = actions.get(0); + assertTrue(action.hasCreateChildWorkflow()); - OrchestratorActions.CreateSubOrchestrationAction createSub = action.getCreateSubOrchestration(); + OrchestratorActions.CreateChildWorkflowAction createSub = action.getCreateChildWorkflow(); assertTrue(createSub.hasRouter()); assertEquals(sourceAppId, createSub.getRouter().getSourceAppID()); assertEquals(targetAppId, createSub.getRouter().getTargetAppID()); From c2dccea6c27d132a5f42b05a3f424d7730da6087 Mon Sep 17 00:00:00 2001 From: Javier Aliaga Date: Fri, 27 Mar 2026 13:08:33 +0100 Subject: [PATCH 09/27] chore: Deprecate invoke methods (#1666) * chore: Deprecate invoke methods Signed-off-by: Javier Aliaga * chore: Deprecate invoke methods Signed-off-by: Javier Aliaga * chore: Deprecate invoke methods Signed-off-by: Javier Aliaga * chore: Change examples Signed-off-by: Javier Aliaga --------- Signed-off-by: Javier Aliaga Co-authored-by: Siri Varma Vegiraju Co-authored-by: salaboy Co-authored-by: Cassie Coyle Co-authored-by: Dapr Bot <56698301+dapr-bot@users.noreply.github.com> --- .../dapr/examples/tracing/InvokeClient.java | 78 ++++++++++++------- .../TracingDemoMiddleServiceController.java | 60 +++++++++----- .../it/methodinvoke/http/MethodInvokeIT.java | 1 + .../io/dapr/it/tracing/grpc/TracingIT.java | 1 + .../io/dapr/it/tracing/http/TracingIT.java | 1 + .../io/dapr/client/AbstractDaprClient.java | 10 +++ .../main/java/io/dapr/client/DaprClient.java | 33 ++++++++ .../java/io/dapr/client/DaprClientImpl.java | 2 + .../io/dapr/client/DaprClientHttpTest.java | 1 + .../java/io/dapr/runtime/DaprRuntimeTest.java | 1 + 10 files changed, 142 insertions(+), 46 deletions(-) diff --git a/examples/src/main/java/io/dapr/examples/tracing/InvokeClient.java b/examples/src/main/java/io/dapr/examples/tracing/InvokeClient.java index 62a9768746..5bbd7b4bc9 100644 --- a/examples/src/main/java/io/dapr/examples/tracing/InvokeClient.java +++ b/examples/src/main/java/io/dapr/examples/tracing/InvokeClient.java @@ -13,19 +13,21 @@ package io.dapr.examples.tracing; -import io.dapr.client.DaprClient; -import io.dapr.client.DaprClientBuilder; -import io.dapr.client.domain.HttpExtension; -import io.dapr.client.domain.InvokeMethodRequest; +import io.dapr.config.Properties; import io.dapr.examples.OpenTelemetryConfig; -import io.dapr.utils.TypeRef; +import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.api.trace.Span; import io.opentelemetry.api.trace.SpanKind; import io.opentelemetry.api.trace.Tracer; +import io.opentelemetry.context.Context; import io.opentelemetry.context.Scope; +import io.opentelemetry.context.propagation.TextMapSetter; import io.opentelemetry.sdk.OpenTelemetrySdk; -import static io.dapr.examples.OpenTelemetryConfig.getReactorContext; +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; /** * 1. Build and install jars: @@ -52,30 +54,50 @@ public static void main(String[] args) throws Exception { Tracer tracer = openTelemetrySdk.getTracer(InvokeClient.class.getCanonicalName()); Span span = tracer.spanBuilder("Example's Main").setSpanKind(SpanKind.CLIENT).startSpan(); - try (DaprClient client = (new DaprClientBuilder()).build()) { - for (String message : args) { - try (Scope scope = span.makeCurrent()) { - InvokeMethodRequest request = new InvokeMethodRequest(SERVICE_APP_ID, "proxy_echo") - .setBody(message) - .setHttpExtension(HttpExtension.POST); - client.invokeMethod(request, TypeRef.get(byte[].class)) - .map(r -> { - System.out.println(new String(r)); - return r; - }) - .flatMap(r -> { - InvokeMethodRequest sleepRequest = new InvokeMethodRequest(SERVICE_APP_ID, "proxy_sleep") - .setHttpExtension(HttpExtension.POST); - return client.invokeMethod(sleepRequest, TypeRef.get(Void.class)); - }).contextWrite(getReactorContext()).block(); - } + int port = Properties.HTTP_PORT.get(); + String baseUrl = "http://localhost:" + port + "/v1.0/invoke/" + SERVICE_APP_ID + "/method/"; + + HttpClient httpClient = HttpClient.newHttpClient(); + + for (String message : args) { + try (Scope scope = span.makeCurrent()) { + // Call proxy_echo + HttpRequest.Builder echoBuilder = HttpRequest.newBuilder() + .uri(URI.create(baseUrl + "proxy_echo")) + .POST(HttpRequest.BodyPublishers.ofString(message)); + injectTraceContext(echoBuilder); + addDaprApiToken(echoBuilder); + HttpResponse echoResponse = + httpClient.send(echoBuilder.build(), HttpResponse.BodyHandlers.ofByteArray()); + System.out.println(new String(echoResponse.body())); + + // Call proxy_sleep + HttpRequest.Builder sleepBuilder = HttpRequest.newBuilder() + .uri(URI.create(baseUrl + "proxy_sleep")) + .POST(HttpRequest.BodyPublishers.noBody()); + injectTraceContext(sleepBuilder); + addDaprApiToken(sleepBuilder); + httpClient.send(sleepBuilder.build(), HttpResponse.BodyHandlers.discarding()); } + } + + span.end(); + openTelemetrySdk.getSdkTracerProvider().shutdown(); + Validation.validate(); + System.out.println("Done"); + System.exit(0); + } + + private static void injectTraceContext(HttpRequest.Builder builder) { + TextMapSetter setter = HttpRequest.Builder::header; + GlobalOpenTelemetry.getPropagators().getTextMapPropagator() + .inject(Context.current(), builder, setter); + } - span.end(); - openTelemetrySdk.getSdkTracerProvider().shutdown(); - Validation.validate(); - System.out.println("Done"); - System.exit(0); + private static void addDaprApiToken(HttpRequest.Builder builder) { + String token = Properties.API_TOKEN.get(); + if (token != null) { + builder.header("dapr-api-token", token); } } } diff --git a/examples/src/main/java/io/dapr/examples/tracing/TracingDemoMiddleServiceController.java b/examples/src/main/java/io/dapr/examples/tracing/TracingDemoMiddleServiceController.java index 323d4c0232..134deda33c 100644 --- a/examples/src/main/java/io/dapr/examples/tracing/TracingDemoMiddleServiceController.java +++ b/examples/src/main/java/io/dapr/examples/tracing/TracingDemoMiddleServiceController.java @@ -13,20 +13,21 @@ package io.dapr.examples.tracing; -import io.dapr.client.DaprClient; -import io.dapr.client.domain.HttpExtension; -import io.dapr.client.domain.InvokeMethodRequest; +import io.dapr.config.Properties; import io.dapr.examples.OpenTelemetryInterceptor; -import io.dapr.utils.TypeRef; +import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.context.Context; -import org.springframework.beans.factory.annotation.Autowired; +import io.opentelemetry.context.propagation.TextMapSetter; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestAttribute; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RestController; import reactor.core.publisher.Mono; -import static io.dapr.examples.OpenTelemetryConfig.getReactorContext; +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; /** * SpringBoot Controller to handle service invocation. @@ -38,11 +39,7 @@ public class TracingDemoMiddleServiceController { private static final String INVOKE_APP_ID = "tracingdemo"; - /** - * Dapr client. - */ - @Autowired - private DaprClient client; + private static final HttpClient httpClient = HttpClient.newHttpClient(); /** * Handles the 'echo' method invocation, by proxying a call into another service. @@ -55,10 +52,14 @@ public class TracingDemoMiddleServiceController { public Mono echo( @RequestAttribute(name = "opentelemetry-context") Context context, @RequestBody(required = false) String body) { - InvokeMethodRequest request = new InvokeMethodRequest(INVOKE_APP_ID, "echo") - .setBody(body) - .setHttpExtension(HttpExtension.POST); - return client.invokeMethod(request, TypeRef.get(byte[].class)).contextWrite(getReactorContext(context)); + return Mono.fromFuture(() -> { + HttpRequest.Builder builder = HttpRequest.newBuilder() + .uri(URI.create(buildInvokeUrl("echo"))) + .POST(HttpRequest.BodyPublishers.ofString(body != null ? body : "")); + injectTraceContext(builder, context); + addDaprApiToken(builder); + return httpClient.sendAsync(builder.build(), HttpResponse.BodyHandlers.ofByteArray()); + }).map(HttpResponse::body); } /** @@ -69,9 +70,32 @@ public Mono echo( */ @PostMapping(path = "/proxy_sleep") public Mono sleep(@RequestAttribute(name = "opentelemetry-context") Context context) { - InvokeMethodRequest request = new InvokeMethodRequest(INVOKE_APP_ID, "sleep") - .setHttpExtension(HttpExtension.POST); - return client.invokeMethod(request, TypeRef.get(byte[].class)).contextWrite(getReactorContext(context)).then(); + return Mono.fromFuture(() -> { + HttpRequest.Builder builder = HttpRequest.newBuilder() + .uri(URI.create(buildInvokeUrl("sleep"))) + .POST(HttpRequest.BodyPublishers.noBody()); + injectTraceContext(builder, context); + addDaprApiToken(builder); + return httpClient.sendAsync(builder.build(), HttpResponse.BodyHandlers.discarding()); + }).then(); + } + + private static String buildInvokeUrl(String method) { + int port = Properties.HTTP_PORT.get(); + return "http://localhost:" + port + "/v1.0/invoke/" + INVOKE_APP_ID + "/method/" + method; + } + + private static void injectTraceContext(HttpRequest.Builder builder, Context context) { + TextMapSetter setter = HttpRequest.Builder::header; + GlobalOpenTelemetry.getPropagators().getTextMapPropagator() + .inject(context, builder, setter); + } + + private static void addDaprApiToken(HttpRequest.Builder builder) { + String token = Properties.API_TOKEN.get(); + if (token != null) { + builder.header("dapr-api-token", token); + } } } diff --git a/sdk-tests/src/test/java/io/dapr/it/methodinvoke/http/MethodInvokeIT.java b/sdk-tests/src/test/java/io/dapr/it/methodinvoke/http/MethodInvokeIT.java index 9d9ac02f8b..3c1ee01b51 100644 --- a/sdk-tests/src/test/java/io/dapr/it/methodinvoke/http/MethodInvokeIT.java +++ b/sdk-tests/src/test/java/io/dapr/it/methodinvoke/http/MethodInvokeIT.java @@ -23,6 +23,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; +@SuppressWarnings("deprecation") public class MethodInvokeIT extends BaseIT { //Number of messages to be sent: 10 diff --git a/sdk-tests/src/test/java/io/dapr/it/tracing/grpc/TracingIT.java b/sdk-tests/src/test/java/io/dapr/it/tracing/grpc/TracingIT.java index 2563473981..43f982eed4 100644 --- a/sdk-tests/src/test/java/io/dapr/it/tracing/grpc/TracingIT.java +++ b/sdk-tests/src/test/java/io/dapr/it/tracing/grpc/TracingIT.java @@ -21,6 +21,7 @@ import static io.dapr.it.tracing.OpenTelemetry.createOpenTelemetry; import static io.dapr.it.tracing.OpenTelemetry.getReactorContext; +@SuppressWarnings("deprecation") public class TracingIT extends BaseIT { /** diff --git a/sdk-tests/src/test/java/io/dapr/it/tracing/http/TracingIT.java b/sdk-tests/src/test/java/io/dapr/it/tracing/http/TracingIT.java index 3285d2ca84..b133ce7213 100644 --- a/sdk-tests/src/test/java/io/dapr/it/tracing/http/TracingIT.java +++ b/sdk-tests/src/test/java/io/dapr/it/tracing/http/TracingIT.java @@ -19,6 +19,7 @@ import static io.dapr.it.tracing.OpenTelemetry.createOpenTelemetry; import static io.dapr.it.tracing.OpenTelemetry.getReactorContext; +@SuppressWarnings("deprecation") public class TracingIT extends BaseIT { /** diff --git a/sdk/src/main/java/io/dapr/client/AbstractDaprClient.java b/sdk/src/main/java/io/dapr/client/AbstractDaprClient.java index c9c4bf8ca4..52e1fb069d 100644 --- a/sdk/src/main/java/io/dapr/client/AbstractDaprClient.java +++ b/sdk/src/main/java/io/dapr/client/AbstractDaprClient.java @@ -116,6 +116,7 @@ public Mono publishEvent(String pubsubName, String topicName, Object data, * {@inheritDoc} */ @Override + @Deprecated public Mono invokeMethod( String appId, String methodName, @@ -136,6 +137,7 @@ public Mono invokeMethod( * {@inheritDoc} */ @Override + @Deprecated public Mono invokeMethod( String appId, String methodName, @@ -150,6 +152,7 @@ public Mono invokeMethod( * {@inheritDoc} */ @Override + @Deprecated public Mono invokeMethod( String appId, String methodName, HttpExtension httpExtension, Map metadata, TypeRef type) { return this.invokeMethod(appId, methodName, null, httpExtension, metadata, type); @@ -159,6 +162,7 @@ public Mono invokeMethod( * {@inheritDoc} */ @Override + @Deprecated public Mono invokeMethod( String appId, String methodName, HttpExtension httpExtension, Map metadata, Class clazz) { return this.invokeMethod(appId, methodName, null, httpExtension, metadata, TypeRef.get(clazz)); @@ -168,6 +172,7 @@ public Mono invokeMethod( * {@inheritDoc} */ @Override + @Deprecated public Mono invokeMethod(String appId, String methodName, Object request, HttpExtension httpExtension, TypeRef type) { return this.invokeMethod(appId, methodName, request, httpExtension, null, type); @@ -177,6 +182,7 @@ public Mono invokeMethod(String appId, String methodName, Object request, * {@inheritDoc} */ @Override + @Deprecated public Mono invokeMethod(String appId, String methodName, Object request, HttpExtension httpExtension, Class clazz) { return this.invokeMethod(appId, methodName, request, httpExtension, null, TypeRef.get(clazz)); @@ -186,6 +192,7 @@ public Mono invokeMethod(String appId, String methodName, Object request, * {@inheritDoc} */ @Override + @Deprecated public Mono invokeMethod(String appId, String methodName, Object request, HttpExtension httpExtension) { return this.invokeMethod(appId, methodName, request, httpExtension, null, TypeRef.BYTE_ARRAY).then(); } @@ -194,6 +201,7 @@ public Mono invokeMethod(String appId, String methodName, Object request, * {@inheritDoc} */ @Override + @Deprecated public Mono invokeMethod( String appId, String methodName, Object request, HttpExtension httpExtension, Map metadata) { return this.invokeMethod(appId, methodName, request, httpExtension, metadata, TypeRef.BYTE_ARRAY).then(); @@ -203,6 +211,7 @@ public Mono invokeMethod( * {@inheritDoc} */ @Override + @Deprecated public Mono invokeMethod( String appId, String methodName, HttpExtension httpExtension, Map metadata) { return this.invokeMethod(appId, methodName, null, httpExtension, metadata, TypeRef.BYTE_ARRAY).then(); @@ -212,6 +221,7 @@ public Mono invokeMethod( * {@inheritDoc} */ @Override + @Deprecated public Mono invokeMethod( String appId, String methodName, byte[] request, HttpExtension httpExtension, Map metadata) { return this.invokeMethod(appId, methodName, request, httpExtension, metadata, TypeRef.BYTE_ARRAY); diff --git a/sdk/src/main/java/io/dapr/client/DaprClient.java b/sdk/src/main/java/io/dapr/client/DaprClient.java index ddf89f587f..00acb18971 100644 --- a/sdk/src/main/java/io/dapr/client/DaprClient.java +++ b/sdk/src/main/java/io/dapr/client/DaprClient.java @@ -178,7 +178,10 @@ Mono> publishEvents(String pubsubName, String topicNa * @param type The Type needed as return for the call. * @param The Type of the return, use byte[] to skip serialization. * @return A Mono Plan of type T. + * + * @deprecated It is recommended to use language-native HTTP clients or gRPC clients for service invocation instead. */ + @Deprecated Mono invokeMethod(String appId, String methodName, Object data, HttpExtension httpExtension, Map metadata, TypeRef type); @@ -194,7 +197,10 @@ Mono invokeMethod(String appId, String methodName, Object data, HttpExten * @param clazz The type needed as return for the call. * @param The Type of the return, use byte[] to skip serialization. * @return A Mono Plan of type T. + * + * @deprecated It is recommended to use language-native HTTP clients or gRPC clients for service invocation instead. */ + @Deprecated Mono invokeMethod(String appId, String methodName, Object request, HttpExtension httpExtension, Map metadata, Class clazz); @@ -209,7 +215,10 @@ Mono invokeMethod(String appId, String methodName, Object request, HttpEx * @param type The Type needed as return for the call. * @param The Type of the return, use byte[] to skip serialization. * @return A Mono Plan of type T. + * + * @deprecated It is recommended to use language-native HTTP clients or gRPC clients for service invocation instead. */ + @Deprecated Mono invokeMethod(String appId, String methodName, Object request, HttpExtension httpExtension, TypeRef type); @@ -224,7 +233,10 @@ Mono invokeMethod(String appId, String methodName, Object request, HttpEx * @param clazz The type needed as return for the call. * @param The Type of the return, use byte[] to skip serialization. * @return A Mono Plan of type T. + * + * @deprecated It is recommended to use language-native HTTP clients or gRPC clients for service invocation instead. */ + @Deprecated Mono invokeMethod(String appId, String methodName, Object request, HttpExtension httpExtension, Class clazz); @@ -239,7 +251,10 @@ Mono invokeMethod(String appId, String methodName, Object request, HttpEx * @param type The Type needed as return for the call. * @param The Type of the return, use byte[] to skip serialization. * @return A Mono Plan of type T. + * + * @deprecated It is recommended to use language-native HTTP clients or gRPC clients for service invocation instead. */ + @Deprecated Mono invokeMethod(String appId, String methodName, HttpExtension httpExtension, Map metadata, TypeRef type); @@ -254,7 +269,10 @@ Mono invokeMethod(String appId, String methodName, HttpExtension httpExte * @param clazz The type needed as return for the call. * @param The Type of the return, use byte[] to skip serialization. * @return A Mono Plan of type T. + * + * @deprecated It is recommended to use language-native HTTP clients or gRPC clients for service invocation instead. */ + @Deprecated Mono invokeMethod(String appId, String methodName, HttpExtension httpExtension, Map metadata, Class clazz); @@ -268,7 +286,10 @@ Mono invokeMethod(String appId, String methodName, HttpExtension httpExte * HTTP, {@link HttpExtension#NONE} otherwise. * @param metadata Metadata (in GRPC) or headers (in HTTP) to be sent in request. * @return A Mono Plan of type Void. + * + * @deprecated It is recommended to use language-native HTTP clients or gRPC clients for service invocation instead. */ + @Deprecated Mono invokeMethod(String appId, String methodName, Object request, HttpExtension httpExtension, Map metadata); @@ -281,7 +302,10 @@ Mono invokeMethod(String appId, String methodName, Object request, HttpExt * @param httpExtension Additional fields that are needed if the receiving app is listening on * HTTP, {@link HttpExtension#NONE} otherwise. * @return A Mono Plan of type Void. + * + * @deprecated It is recommended to use language-native HTTP clients or gRPC clients for service invocation instead. */ + @Deprecated Mono invokeMethod(String appId, String methodName, Object request, HttpExtension httpExtension); /** @@ -293,7 +317,10 @@ Mono invokeMethod(String appId, String methodName, Object request, HttpExt * HTTP, {@link HttpExtension#NONE} otherwise. * @param metadata Metadata (in GRPC) or headers (in HTTP) to be sent in request. * @return A Mono Plan of type Void. + * + * @deprecated It is recommended to use language-native HTTP clients or gRPC clients for service invocation instead. */ + @Deprecated Mono invokeMethod(String appId, String methodName, HttpExtension httpExtension, Map metadata); /** @@ -306,7 +333,10 @@ Mono invokeMethod(String appId, String methodName, Object request, HttpExt * HTTP, {@link HttpExtension#NONE} otherwise. * @param metadata Metadata (in GRPC) or headers (in HTTP) to be sent in request. * @return A Mono Plan of type byte[]. + * + * @deprecated It is recommended to use language-native HTTP clients or gRPC clients for service invocation instead. */ + @Deprecated Mono invokeMethod(String appId, String methodName, byte[] request, HttpExtension httpExtension, Map metadata); @@ -317,7 +347,10 @@ Mono invokeMethod(String appId, String methodName, byte[] request, HttpE * @param type The Type needed as return for the call. * @param The Type of the return, use byte[] to skip serialization. * @return A Mono Plan of type T. + * + * @deprecated It is recommended to use language-native HTTP clients or gRPC clients for service invocation instead. */ + @Deprecated Mono invokeMethod(InvokeMethodRequest invokeMethodRequest, TypeRef type); /** diff --git a/sdk/src/main/java/io/dapr/client/DaprClientImpl.java b/sdk/src/main/java/io/dapr/client/DaprClientImpl.java index 60c7568377..e5c95ec0d7 100644 --- a/sdk/src/main/java/io/dapr/client/DaprClientImpl.java +++ b/sdk/src/main/java/io/dapr/client/DaprClientImpl.java @@ -128,6 +128,7 @@ import reactor.util.retry.Retry; import javax.annotation.Nonnull; + import java.io.IOException; import java.time.Duration; import java.time.Instant; @@ -606,6 +607,7 @@ private Subscription buildSubscription( } @Override + @Deprecated public Mono invokeMethod(InvokeMethodRequest invokeMethodRequest, TypeRef type) { try { final String appId = invokeMethodRequest.getAppId(); diff --git a/sdk/src/test/java/io/dapr/client/DaprClientHttpTest.java b/sdk/src/test/java/io/dapr/client/DaprClientHttpTest.java index ca3c1c5341..af6791d7e1 100644 --- a/sdk/src/test/java/io/dapr/client/DaprClientHttpTest.java +++ b/sdk/src/test/java/io/dapr/client/DaprClientHttpTest.java @@ -54,6 +54,7 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +@SuppressWarnings("deprecation") public class DaprClientHttpTest { private final String EXPECTED_RESULT = diff --git a/sdk/src/test/java/io/dapr/runtime/DaprRuntimeTest.java b/sdk/src/test/java/io/dapr/runtime/DaprRuntimeTest.java index 2343ca0591..7e2faafd09 100644 --- a/sdk/src/test/java/io/dapr/runtime/DaprRuntimeTest.java +++ b/sdk/src/test/java/io/dapr/runtime/DaprRuntimeTest.java @@ -44,6 +44,7 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +@SuppressWarnings("deprecation") public class DaprRuntimeTest { protected static final JsonFactory JSON_FACTORY = new JsonFactory(); From a0fcd2b9ac520705c30221d84d0d68589f21f38e Mon Sep 17 00:00:00 2001 From: Javier Aliaga Date: Tue, 31 Mar 2026 15:32:06 +0200 Subject: [PATCH 10/27] fix: upgrade dependencies to address critical CVEs (#1706) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix: upgrade dependencies to address critical CVEs Upgrade jackson-bom 2.16.2 → 2.18.6 (CVE-2025-52999, CVSS 8.7 DoS), add netty-bom 4.1.132.Final (CVE-2026-33871 CVSS 8.7, CVE-2026-33870 CVSS 7.5), and bump Spring Boot 3.4.9 → 3.4.10 which pulls Tomcat 10.1.46 (CVE-2025-55754 CVSS 9.6, CVE-2025-55752 CVSS 7.5). Reorder BOM imports so netty-bom and jackson-bom take precedence over Spring Boot's managed versions. Align springframework.version 6.2.11 with Spring Boot 3.4.10. Signed-off-by: Javier Aliaga * chore: add TODO to remove netty-bom once gRPC bundles >= 4.1.132 Signed-off-by: Javier Aliaga * fix: upgrade Spring Boot 4.0.2 to 4.0.5 to fix jackson-core 3.0.4 (GHSA-72hv-8253-57qq) Spring Boot 4.0.4+ ships with jackson 3.1.0, fixing the async JSON parser DoS vulnerability in jackson-core 3.0.4. Upgrade all 6 modules that pin springboot4.version from 4.0.2 to 4.0.5 (latest patch). No jackson-bom override needed — Spring Boot 4.0.5 manages it natively. Signed-off-by: Javier Aliaga --------- Signed-off-by: Javier Aliaga --- dapr-spring/dapr-spring-6-data/pom.xml | 4 +-- .../dapr-spring-boot-4-autoconfigure/pom.xml | 4 +-- .../dapr-spring-boot-4-starter-test/pom.xml | 4 +-- .../dapr-spring-boot-4-starter/pom.xml | 4 +-- pom.xml | 27 ++++++++++++------- spring-boot-4-examples/pom.xml | 4 +-- spring-boot-4-sdk-tests/pom.xml | 4 +-- 7 files changed, 30 insertions(+), 21 deletions(-) diff --git a/dapr-spring/dapr-spring-6-data/pom.xml b/dapr-spring/dapr-spring-6-data/pom.xml index 5142cfdac1..46411f07c3 100644 --- a/dapr-spring/dapr-spring-6-data/pom.xml +++ b/dapr-spring/dapr-spring-6-data/pom.xml @@ -17,8 +17,8 @@ jar - 4.0.2 - + 4.0.5 + 6.0.2 diff --git a/dapr-spring/dapr-spring-boot-4-autoconfigure/pom.xml b/dapr-spring/dapr-spring-boot-4-autoconfigure/pom.xml index 17dabbcb78..c5b93b8f02 100644 --- a/dapr-spring/dapr-spring-boot-4-autoconfigure/pom.xml +++ b/dapr-spring/dapr-spring-boot-4-autoconfigure/pom.xml @@ -16,8 +16,8 @@ jar - 4.0.2 - + 4.0.5 + 6.0.2 diff --git a/dapr-spring/dapr-spring-boot-starters/dapr-spring-boot-4-starter-test/pom.xml b/dapr-spring/dapr-spring-boot-starters/dapr-spring-boot-4-starter-test/pom.xml index 52cc83fec3..cec099f640 100644 --- a/dapr-spring/dapr-spring-boot-starters/dapr-spring-boot-4-starter-test/pom.xml +++ b/dapr-spring/dapr-spring-boot-starters/dapr-spring-boot-4-starter-test/pom.xml @@ -16,8 +16,8 @@ jar - 4.0.2 - + 4.0.5 + 6.0.2 diff --git a/dapr-spring/dapr-spring-boot-starters/dapr-spring-boot-4-starter/pom.xml b/dapr-spring/dapr-spring-boot-starters/dapr-spring-boot-4-starter/pom.xml index 96c3aed531..4744517a8d 100644 --- a/dapr-spring/dapr-spring-boot-starters/dapr-spring-boot-4-starter/pom.xml +++ b/dapr-spring/dapr-spring-boot-starters/dapr-spring-boot-4-starter/pom.xml @@ -16,8 +16,8 @@ jar - 4.0.2 - + 4.0.5 + 6.0.2 diff --git a/pom.xml b/pom.xml index fe3bd5cd23..68109943f0 100644 --- a/pom.xml +++ b/pom.xml @@ -42,7 +42,7 @@ 11 11 true - 2.16.2 + 2.18.6 true true ${maven.multiModuleProjectDirectory}/spotbugs-exclude.xml @@ -53,8 +53,8 @@ 2.0 1.21.4 - 3.4.9 - 6.2.7 + 3.4.10 + 6.2.11 1.7.0 3.27.7 @@ -82,6 +82,8 @@ 2.1.0 2.1.0 5.5.1 + + 4.1.132.Final @@ -106,16 +108,16 @@ - io.grpc - grpc-bom - ${grpc.version} + io.netty + netty-bom + ${netty.version} pom import - org.springframework.boot - spring-boot-dependencies - ${springboot.version} + io.grpc + grpc-bom + ${grpc.version} pom import @@ -126,6 +128,13 @@ pom import + + org.springframework.boot + spring-boot-dependencies + ${springboot.version} + pom + import + org.junit junit-bom diff --git a/spring-boot-4-examples/pom.xml b/spring-boot-4-examples/pom.xml index 0cd744abcd..ba4830ffe3 100644 --- a/spring-boot-4-examples/pom.xml +++ b/spring-boot-4-examples/pom.xml @@ -15,8 +15,8 @@ true - 4.0.2 - + 4.0.5 + 6.0.2 diff --git a/spring-boot-4-sdk-tests/pom.xml b/spring-boot-4-sdk-tests/pom.xml index d6874b9625..684eaf742e 100644 --- a/spring-boot-4-sdk-tests/pom.xml +++ b/spring-boot-4-sdk-tests/pom.xml @@ -19,8 +19,8 @@ true ${project.build.directory}/generated-sources ${project.basedir}/proto - 4.0.2 - + 4.0.5 + 6.0.2 From 61b9e6128c1c6e4cf9fc8ba5dbc316985b94618e Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 31 Mar 2026 07:49:40 -0700 Subject: [PATCH 11/27] chore(deps): Bump codecov/codecov-action from 5.5.2 to 5.5.3 (#1700) Bumps [codecov/codecov-action](https://github.com/codecov/codecov-action) from 5.5.2 to 5.5.3. - [Release notes](https://github.com/codecov/codecov-action/releases) - [Changelog](https://github.com/codecov/codecov-action/blob/main/CHANGELOG.md) - [Commits](https://github.com/codecov/codecov-action/compare/v5.5.2...v5.5.3) --- updated-dependencies: - dependency-name: codecov/codecov-action dependency-version: 5.5.3 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Javier Aliaga Co-authored-by: Dapr Bot <56698301+dapr-bot@users.noreply.github.com> --- .github/workflows/build.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 966d461be2..c14a010350 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -32,7 +32,7 @@ jobs: - name: Run tests run: ./mvnw clean install -B -q -DskipITs=true - name: Codecov - uses: codecov/codecov-action@v5.5.2 + uses: codecov/codecov-action@v5.5.3 with: token: ${{ secrets.CODECOV_TOKEN }} - name: Upload test report for sdk From 0a9fae8f64d03e3a2857243e115881c645656468 Mon Sep 17 00:00:00 2001 From: Dapr Bot Date: Thu, 2 Apr 2026 07:54:16 +0000 Subject: [PATCH 12/27] Generate updated javadocs for 1.17.1 Signed-off-by: Dapr Bot --- README.md | 12 ++++++------ docs/allclasses-index.html | 2 +- docs/allpackages-index.html | 2 +- docs/constant-values.html | 2 +- docs/dapr-sdk-workflows/allclasses-index.html | 2 +- docs/dapr-sdk-workflows/allpackages-index.html | 2 +- docs/dapr-sdk-workflows/help-doc.html | 2 +- docs/dapr-sdk-workflows/index-all.html | 2 +- docs/dapr-sdk-workflows/index.html | 4 ++-- .../io/dapr/workflows/Workflow.html | 2 +- .../io/dapr/workflows/WorkflowContext.html | 2 +- .../io/dapr/workflows/WorkflowStub.html | 2 +- .../io/dapr/workflows/class-use/Workflow.html | 2 +- .../io/dapr/workflows/class-use/WorkflowContext.html | 2 +- .../io/dapr/workflows/class-use/WorkflowStub.html | 2 +- .../io/dapr/workflows/client/DaprWorkflowClient.html | 2 +- .../workflows/client/WorkflowFailureDetails.html | 2 +- .../workflows/client/WorkflowInstanceStatus.html | 2 +- .../client/class-use/DaprWorkflowClient.html | 2 +- .../client/class-use/WorkflowFailureDetails.html | 2 +- .../client/class-use/WorkflowInstanceStatus.html | 2 +- .../io/dapr/workflows/client/package-summary.html | 2 +- .../io/dapr/workflows/client/package-tree.html | 2 +- .../io/dapr/workflows/client/package-use.html | 2 +- .../internal/ApiTokenClientInterceptor.html | 2 +- .../class-use/ApiTokenClientInterceptor.html | 2 +- .../io/dapr/workflows/internal/package-summary.html | 2 +- .../io/dapr/workflows/internal/package-tree.html | 2 +- .../io/dapr/workflows/internal/package-use.html | 2 +- .../io/dapr/workflows/package-summary.html | 2 +- .../io/dapr/workflows/package-tree.html | 2 +- .../io/dapr/workflows/package-use.html | 2 +- .../io/dapr/workflows/runtime/WorkflowRuntime.html | 2 +- .../workflows/runtime/WorkflowRuntimeBuilder.html | 2 +- .../workflows/runtime/class-use/WorkflowRuntime.html | 2 +- .../runtime/class-use/WorkflowRuntimeBuilder.html | 2 +- .../io/dapr/workflows/runtime/package-summary.html | 2 +- .../io/dapr/workflows/runtime/package-tree.html | 2 +- .../io/dapr/workflows/runtime/package-use.html | 2 +- docs/dapr-sdk-workflows/overview-summary.html | 2 +- docs/dapr-sdk-workflows/overview-tree.html | 2 +- docs/dapr-sdk-workflows/project-reports.html | 6 +++--- docs/deprecated-list.html | 2 +- docs/help-doc.html | 2 +- docs/index-all.html | 2 +- docs/index.html | 4 ++-- docs/io/dapr/Rule.html | 2 +- docs/io/dapr/Topic.html | 2 +- docs/io/dapr/actors/ActorId.html | 2 +- docs/io/dapr/actors/ActorMethod.html | 2 +- docs/io/dapr/actors/ActorTrace.html | 2 +- docs/io/dapr/actors/ActorType.html | 2 +- docs/io/dapr/actors/ActorUtils.html | 2 +- docs/io/dapr/actors/class-use/ActorId.html | 2 +- docs/io/dapr/actors/class-use/ActorMethod.html | 2 +- docs/io/dapr/actors/class-use/ActorTrace.html | 2 +- docs/io/dapr/actors/class-use/ActorType.html | 2 +- docs/io/dapr/actors/class-use/ActorUtils.html | 2 +- docs/io/dapr/actors/client/ActorClient.html | 2 +- docs/io/dapr/actors/client/ActorProxy.html | 2 +- docs/io/dapr/actors/client/ActorProxyBuilder.html | 2 +- .../io/dapr/actors/client/class-use/ActorClient.html | 2 +- docs/io/dapr/actors/client/class-use/ActorProxy.html | 2 +- .../actors/client/class-use/ActorProxyBuilder.html | 2 +- docs/io/dapr/actors/client/package-summary.html | 2 +- docs/io/dapr/actors/client/package-tree.html | 2 +- docs/io/dapr/actors/client/package-use.html | 2 +- docs/io/dapr/actors/package-summary.html | 2 +- docs/io/dapr/actors/package-tree.html | 2 +- docs/io/dapr/actors/package-use.html | 2 +- docs/io/dapr/actors/runtime/AbstractActor.html | 2 +- docs/io/dapr/actors/runtime/ActorFactory.html | 2 +- docs/io/dapr/actors/runtime/ActorMethodContext.html | 2 +- .../dapr/actors/runtime/ActorObjectSerializer.html | 2 +- docs/io/dapr/actors/runtime/ActorRuntime.html | 2 +- docs/io/dapr/actors/runtime/ActorRuntimeConfig.html | 2 +- docs/io/dapr/actors/runtime/ActorRuntimeContext.html | 2 +- docs/io/dapr/actors/runtime/ActorStateChange.html | 2 +- .../io/dapr/actors/runtime/ActorStateChangeKind.html | 2 +- docs/io/dapr/actors/runtime/ActorStateManager.html | 2 +- docs/io/dapr/actors/runtime/ActorTypeConfig.html | 2 +- docs/io/dapr/actors/runtime/Remindable.html | 2 +- .../dapr/actors/runtime/class-use/AbstractActor.html | 2 +- .../dapr/actors/runtime/class-use/ActorFactory.html | 2 +- .../actors/runtime/class-use/ActorMethodContext.html | 2 +- .../runtime/class-use/ActorObjectSerializer.html | 2 +- .../dapr/actors/runtime/class-use/ActorRuntime.html | 2 +- .../actors/runtime/class-use/ActorRuntimeConfig.html | 2 +- .../runtime/class-use/ActorRuntimeContext.html | 2 +- .../actors/runtime/class-use/ActorStateChange.html | 2 +- .../runtime/class-use/ActorStateChangeKind.html | 2 +- .../actors/runtime/class-use/ActorStateManager.html | 2 +- .../actors/runtime/class-use/ActorTypeConfig.html | 2 +- .../io/dapr/actors/runtime/class-use/Remindable.html | 2 +- docs/io/dapr/actors/runtime/package-summary.html | 2 +- docs/io/dapr/actors/runtime/package-tree.html | 2 +- docs/io/dapr/actors/runtime/package-use.html | 2 +- docs/io/dapr/class-use/Rule.html | 2 +- docs/io/dapr/class-use/Topic.html | 2 +- docs/io/dapr/client/DaprClient.html | 2 +- docs/io/dapr/client/DaprClientBuilder.html | 2 +- docs/io/dapr/client/DaprClientImpl.html | 2 +- docs/io/dapr/client/DaprHttp.HttpMethods.html | 2 +- docs/io/dapr/client/DaprHttp.Response.html | 2 +- docs/io/dapr/client/DaprHttp.html | 2 +- docs/io/dapr/client/DaprHttpBuilder.html | 2 +- docs/io/dapr/client/DaprPreviewClient.html | 2 +- docs/io/dapr/client/Headers.html | 2 +- docs/io/dapr/client/ObjectSerializer.html | 2 +- docs/io/dapr/client/class-use/DaprClient.html | 2 +- docs/io/dapr/client/class-use/DaprClientBuilder.html | 2 +- docs/io/dapr/client/class-use/DaprClientImpl.html | 2 +- .../dapr/client/class-use/DaprHttp.HttpMethods.html | 2 +- docs/io/dapr/client/class-use/DaprHttp.Response.html | 2 +- docs/io/dapr/client/class-use/DaprHttp.html | 2 +- docs/io/dapr/client/class-use/DaprHttpBuilder.html | 2 +- docs/io/dapr/client/class-use/DaprPreviewClient.html | 2 +- docs/io/dapr/client/class-use/Headers.html | 2 +- docs/io/dapr/client/class-use/ObjectSerializer.html | 2 +- docs/io/dapr/client/domain/ActorMetadata.html | 2 +- .../AppConnectionPropertiesHealthMetadata.html | 2 +- .../domain/AppConnectionPropertiesMetadata.html | 2 +- docs/io/dapr/client/domain/BulkPublishEntry.html | 2 +- docs/io/dapr/client/domain/BulkPublishRequest.html | 2 +- docs/io/dapr/client/domain/BulkPublishResponse.html | 2 +- .../domain/BulkPublishResponseFailedEntry.html | 2 +- .../dapr/client/domain/BulkSubscribeAppResponse.html | 2 +- .../client/domain/BulkSubscribeAppResponseEntry.html | 2 +- .../domain/BulkSubscribeAppResponseStatus.html | 2 +- docs/io/dapr/client/domain/BulkSubscribeMessage.html | 2 +- .../client/domain/BulkSubscribeMessageEntry.html | 2 +- docs/io/dapr/client/domain/CloudEvent.html | 2 +- docs/io/dapr/client/domain/ComponentMetadata.html | 2 +- docs/io/dapr/client/domain/ConfigurationItem.html | 2 +- docs/io/dapr/client/domain/DaprMetadata.html | 2 +- docs/io/dapr/client/domain/DeleteStateRequest.html | 2 +- .../domain/ExecuteStateTransactionRequest.html | 2 +- docs/io/dapr/client/domain/GetBulkSecretRequest.html | 2 +- docs/io/dapr/client/domain/GetBulkStateRequest.html | 2 +- .../dapr/client/domain/GetConfigurationRequest.html | 2 +- docs/io/dapr/client/domain/GetSecretRequest.html | 2 +- docs/io/dapr/client/domain/GetStateRequest.html | 2 +- docs/io/dapr/client/domain/HttpEndpointMetadata.html | 2 +- docs/io/dapr/client/domain/HttpExtension.html | 2 +- docs/io/dapr/client/domain/InvokeBindingRequest.html | 2 +- docs/io/dapr/client/domain/InvokeMethodRequest.html | 2 +- docs/io/dapr/client/domain/LockRequest.html | 2 +- docs/io/dapr/client/domain/Metadata.html | 2 +- docs/io/dapr/client/domain/PublishEventRequest.html | 2 +- docs/io/dapr/client/domain/QueryStateItem.html | 2 +- docs/io/dapr/client/domain/QueryStateRequest.html | 2 +- docs/io/dapr/client/domain/QueryStateResponse.html | 2 +- docs/io/dapr/client/domain/RuleMetadata.html | 2 +- docs/io/dapr/client/domain/SaveStateRequest.html | 2 +- docs/io/dapr/client/domain/State.html | 2 +- .../dapr/client/domain/StateOptions.Concurrency.html | 2 +- .../dapr/client/domain/StateOptions.Consistency.html | 2 +- ...StateOptions.StateOptionDurationDeserializer.html | 2 +- .../StateOptions.StateOptionDurationSerializer.html | 2 +- docs/io/dapr/client/domain/StateOptions.html | 2 +- .../client/domain/SubscribeConfigurationRequest.html | 2 +- .../domain/SubscribeConfigurationResponse.html | 2 +- docs/io/dapr/client/domain/SubscriptionMetadata.html | 2 +- .../TransactionalStateOperation.OperationType.html | 2 +- .../client/domain/TransactionalStateOperation.html | 2 +- .../client/domain/TransactionalStateRequest.html | 2 +- docs/io/dapr/client/domain/UnlockRequest.html | 2 +- docs/io/dapr/client/domain/UnlockResponseStatus.html | 2 +- .../domain/UnsubscribeConfigurationRequest.html | 2 +- .../domain/UnsubscribeConfigurationResponse.html | 2 +- .../dapr/client/domain/class-use/ActorMetadata.html | 2 +- .../AppConnectionPropertiesHealthMetadata.html | 2 +- .../class-use/AppConnectionPropertiesMetadata.html | 2 +- .../client/domain/class-use/BulkPublishEntry.html | 2 +- .../client/domain/class-use/BulkPublishRequest.html | 2 +- .../client/domain/class-use/BulkPublishResponse.html | 2 +- .../class-use/BulkPublishResponseFailedEntry.html | 2 +- .../domain/class-use/BulkSubscribeAppResponse.html | 2 +- .../class-use/BulkSubscribeAppResponseEntry.html | 2 +- .../class-use/BulkSubscribeAppResponseStatus.html | 2 +- .../domain/class-use/BulkSubscribeMessage.html | 2 +- .../domain/class-use/BulkSubscribeMessageEntry.html | 2 +- docs/io/dapr/client/domain/class-use/CloudEvent.html | 2 +- .../client/domain/class-use/ComponentMetadata.html | 2 +- .../client/domain/class-use/ConfigurationItem.html | 2 +- .../dapr/client/domain/class-use/DaprMetadata.html | 2 +- .../client/domain/class-use/DeleteStateRequest.html | 2 +- .../class-use/ExecuteStateTransactionRequest.html | 2 +- .../domain/class-use/GetBulkSecretRequest.html | 2 +- .../client/domain/class-use/GetBulkStateRequest.html | 2 +- .../domain/class-use/GetConfigurationRequest.html | 2 +- .../client/domain/class-use/GetSecretRequest.html | 2 +- .../client/domain/class-use/GetStateRequest.html | 2 +- .../domain/class-use/HttpEndpointMetadata.html | 2 +- .../dapr/client/domain/class-use/HttpExtension.html | 2 +- .../domain/class-use/InvokeBindingRequest.html | 2 +- .../client/domain/class-use/InvokeMethodRequest.html | 2 +- .../io/dapr/client/domain/class-use/LockRequest.html | 2 +- docs/io/dapr/client/domain/class-use/Metadata.html | 2 +- .../client/domain/class-use/PublishEventRequest.html | 2 +- .../dapr/client/domain/class-use/QueryStateItem.html | 2 +- .../client/domain/class-use/QueryStateRequest.html | 2 +- .../client/domain/class-use/QueryStateResponse.html | 2 +- .../dapr/client/domain/class-use/RuleMetadata.html | 2 +- .../client/domain/class-use/SaveStateRequest.html | 2 +- docs/io/dapr/client/domain/class-use/State.html | 2 +- .../domain/class-use/StateOptions.Concurrency.html | 2 +- .../domain/class-use/StateOptions.Consistency.html | 2 +- ...StateOptions.StateOptionDurationDeserializer.html | 2 +- .../StateOptions.StateOptionDurationSerializer.html | 2 +- .../dapr/client/domain/class-use/StateOptions.html | 2 +- .../class-use/SubscribeConfigurationRequest.html | 2 +- .../class-use/SubscribeConfigurationResponse.html | 2 +- .../domain/class-use/SubscriptionMetadata.html | 2 +- .../TransactionalStateOperation.OperationType.html | 2 +- .../class-use/TransactionalStateOperation.html | 2 +- .../domain/class-use/TransactionalStateRequest.html | 2 +- .../dapr/client/domain/class-use/UnlockRequest.html | 2 +- .../domain/class-use/UnlockResponseStatus.html | 2 +- .../class-use/UnsubscribeConfigurationRequest.html | 2 +- .../class-use/UnsubscribeConfigurationResponse.html | 2 +- docs/io/dapr/client/domain/package-summary.html | 2 +- docs/io/dapr/client/domain/package-tree.html | 2 +- docs/io/dapr/client/domain/package-use.html | 2 +- docs/io/dapr/client/domain/query/Pagination.html | 2 +- docs/io/dapr/client/domain/query/Query.html | 2 +- docs/io/dapr/client/domain/query/Sorting.Order.html | 2 +- docs/io/dapr/client/domain/query/Sorting.html | 2 +- .../client/domain/query/class-use/Pagination.html | 2 +- .../io/dapr/client/domain/query/class-use/Query.html | 2 +- .../client/domain/query/class-use/Sorting.Order.html | 2 +- .../dapr/client/domain/query/class-use/Sorting.html | 2 +- .../dapr/client/domain/query/filters/AndFilter.html | 2 +- .../dapr/client/domain/query/filters/EqFilter.html | 2 +- docs/io/dapr/client/domain/query/filters/Filter.html | 2 +- .../dapr/client/domain/query/filters/InFilter.html | 2 +- .../dapr/client/domain/query/filters/OrFilter.html | 2 +- .../domain/query/filters/class-use/AndFilter.html | 2 +- .../domain/query/filters/class-use/EqFilter.html | 2 +- .../domain/query/filters/class-use/Filter.html | 2 +- .../domain/query/filters/class-use/InFilter.html | 2 +- .../domain/query/filters/class-use/OrFilter.html | 2 +- .../client/domain/query/filters/package-summary.html | 2 +- .../client/domain/query/filters/package-tree.html | 2 +- .../client/domain/query/filters/package-use.html | 2 +- .../io/dapr/client/domain/query/package-summary.html | 2 +- docs/io/dapr/client/domain/query/package-tree.html | 2 +- docs/io/dapr/client/domain/query/package-use.html | 2 +- docs/io/dapr/client/package-summary.html | 2 +- docs/io/dapr/client/package-tree.html | 2 +- docs/io/dapr/client/package-use.html | 2 +- .../io/dapr/client/resiliency/ResiliencyOptions.html | 2 +- .../resiliency/class-use/ResiliencyOptions.html | 2 +- docs/io/dapr/client/resiliency/package-summary.html | 2 +- docs/io/dapr/client/resiliency/package-tree.html | 2 +- docs/io/dapr/client/resiliency/package-use.html | 2 +- docs/io/dapr/config/BooleanProperty.html | 2 +- docs/io/dapr/config/GenericProperty.html | 2 +- docs/io/dapr/config/IntegerProperty.html | 2 +- .../io/dapr/config/MillisecondsDurationProperty.html | 2 +- docs/io/dapr/config/Properties.html | 2 +- docs/io/dapr/config/Property.html | 2 +- docs/io/dapr/config/StringProperty.html | 2 +- docs/io/dapr/config/class-use/BooleanProperty.html | 2 +- docs/io/dapr/config/class-use/GenericProperty.html | 2 +- docs/io/dapr/config/class-use/IntegerProperty.html | 2 +- .../class-use/MillisecondsDurationProperty.html | 2 +- docs/io/dapr/config/class-use/Properties.html | 2 +- docs/io/dapr/config/class-use/Property.html | 2 +- docs/io/dapr/config/class-use/StringProperty.html | 2 +- docs/io/dapr/config/package-summary.html | 2 +- docs/io/dapr/config/package-tree.html | 2 +- docs/io/dapr/config/package-use.html | 2 +- docs/io/dapr/exceptions/DaprError.html | 2 +- .../exceptions/DaprErrorDetails.ErrorDetailType.html | 2 +- docs/io/dapr/exceptions/DaprErrorDetails.html | 2 +- docs/io/dapr/exceptions/DaprException.html | 2 +- docs/io/dapr/exceptions/class-use/DaprError.html | 2 +- .../class-use/DaprErrorDetails.ErrorDetailType.html | 2 +- .../dapr/exceptions/class-use/DaprErrorDetails.html | 2 +- docs/io/dapr/exceptions/class-use/DaprException.html | 2 +- docs/io/dapr/exceptions/package-summary.html | 2 +- docs/io/dapr/exceptions/package-tree.html | 2 +- docs/io/dapr/exceptions/package-use.html | 2 +- .../internal/grpc/DaprClientGrpcInterceptors.html | 2 +- .../grpc/class-use/DaprClientGrpcInterceptors.html | 2 +- .../grpc/interceptors/DaprApiTokenInterceptor.html | 2 +- .../grpc/interceptors/DaprAppIdInterceptor.html | 2 +- .../grpc/interceptors/DaprTimeoutInterceptor.html | 2 +- .../grpc/interceptors/DaprTracingInterceptor.html | 2 +- .../class-use/DaprApiTokenInterceptor.html | 2 +- .../interceptors/class-use/DaprAppIdInterceptor.html | 2 +- .../class-use/DaprTimeoutInterceptor.html | 2 +- .../class-use/DaprTracingInterceptor.html | 2 +- .../internal/grpc/interceptors/package-summary.html | 2 +- .../internal/grpc/interceptors/package-tree.html | 2 +- .../dapr/internal/grpc/interceptors/package-use.html | 2 +- docs/io/dapr/internal/grpc/package-summary.html | 2 +- docs/io/dapr/internal/grpc/package-tree.html | 2 +- docs/io/dapr/internal/grpc/package-use.html | 2 +- docs/io/dapr/internal/opencensus/GrpcHelper.html | 2 +- .../internal/opencensus/class-use/GrpcHelper.html | 2 +- .../io/dapr/internal/opencensus/package-summary.html | 2 +- docs/io/dapr/internal/opencensus/package-tree.html | 2 +- docs/io/dapr/internal/opencensus/package-use.html | 2 +- docs/io/dapr/internal/resiliency/RetryPolicy.html | 2 +- docs/io/dapr/internal/resiliency/TimeoutPolicy.html | 2 +- .../internal/resiliency/class-use/RetryPolicy.html | 2 +- .../internal/resiliency/class-use/TimeoutPolicy.html | 2 +- .../io/dapr/internal/resiliency/package-summary.html | 2 +- docs/io/dapr/internal/resiliency/package-tree.html | 2 +- docs/io/dapr/internal/resiliency/package-use.html | 2 +- docs/io/dapr/package-summary.html | 2 +- docs/io/dapr/package-tree.html | 2 +- docs/io/dapr/package-use.html | 2 +- docs/io/dapr/serializer/DaprObjectSerializer.html | 2 +- docs/io/dapr/serializer/DefaultObjectSerializer.html | 2 +- .../serializer/class-use/DaprObjectSerializer.html | 2 +- .../class-use/DefaultObjectSerializer.html | 2 +- docs/io/dapr/serializer/package-summary.html | 2 +- docs/io/dapr/serializer/package-tree.html | 2 +- docs/io/dapr/serializer/package-use.html | 2 +- docs/io/dapr/utils/DefaultContentTypeConverter.html | 2 +- docs/io/dapr/utils/DurationUtils.html | 2 +- docs/io/dapr/utils/NetworkUtils.html | 2 +- docs/io/dapr/utils/TypeRef.html | 2 +- docs/io/dapr/utils/Version.html | 2 +- .../utils/class-use/DefaultContentTypeConverter.html | 2 +- docs/io/dapr/utils/class-use/DurationUtils.html | 2 +- docs/io/dapr/utils/class-use/NetworkUtils.html | 2 +- docs/io/dapr/utils/class-use/TypeRef.html | 2 +- docs/io/dapr/utils/class-use/Version.html | 2 +- docs/io/dapr/utils/package-summary.html | 2 +- docs/io/dapr/utils/package-tree.html | 2 +- docs/io/dapr/utils/package-use.html | 2 +- ...llbackAlphaGrpc.AppCallbackAlphaBlockingStub.html | 2 +- ...CallbackAlphaGrpc.AppCallbackAlphaFutureStub.html | 2 +- ...ppCallbackAlphaGrpc.AppCallbackAlphaImplBase.html | 2 +- .../AppCallbackAlphaGrpc.AppCallbackAlphaStub.html | 2 +- .../dapr/v1/AppCallbackAlphaGrpc.AsyncService.html | 2 +- docs/io/dapr/v1/AppCallbackAlphaGrpc.html | 2 +- .../v1/AppCallbackGrpc.AppCallbackBlockingStub.html | 2 +- .../v1/AppCallbackGrpc.AppCallbackFutureStub.html | 2 +- .../dapr/v1/AppCallbackGrpc.AppCallbackImplBase.html | 2 +- docs/io/dapr/v1/AppCallbackGrpc.AppCallbackStub.html | 2 +- docs/io/dapr/v1/AppCallbackGrpc.AsyncService.html | 2 +- docs/io/dapr/v1/AppCallbackGrpc.html | 2 +- ...CheckGrpc.AppCallbackHealthCheckBlockingStub.html | 2 +- ...thCheckGrpc.AppCallbackHealthCheckFutureStub.html | 2 +- ...althCheckGrpc.AppCallbackHealthCheckImplBase.html | 2 +- ...ckHealthCheckGrpc.AppCallbackHealthCheckStub.html | 2 +- .../v1/AppCallbackHealthCheckGrpc.AsyncService.html | 2 +- docs/io/dapr/v1/AppCallbackHealthCheckGrpc.html | 2 +- .../v1/CommonProtos.ConfigurationItem.Builder.html | 2 +- docs/io/dapr/v1/CommonProtos.ConfigurationItem.html | 2 +- .../v1/CommonProtos.ConfigurationItemOrBuilder.html | 2 +- docs/io/dapr/v1/CommonProtos.Etag.Builder.html | 2 +- docs/io/dapr/v1/CommonProtos.Etag.html | 2 +- docs/io/dapr/v1/CommonProtos.EtagOrBuilder.html | 2 +- .../dapr/v1/CommonProtos.HTTPExtension.Builder.html | 2 +- docs/io/dapr/v1/CommonProtos.HTTPExtension.Verb.html | 2 +- docs/io/dapr/v1/CommonProtos.HTTPExtension.html | 2 +- .../dapr/v1/CommonProtos.HTTPExtensionOrBuilder.html | 2 +- .../dapr/v1/CommonProtos.InvokeRequest.Builder.html | 2 +- docs/io/dapr/v1/CommonProtos.InvokeRequest.html | 2 +- .../dapr/v1/CommonProtos.InvokeRequestOrBuilder.html | 2 +- .../dapr/v1/CommonProtos.InvokeResponse.Builder.html | 2 +- docs/io/dapr/v1/CommonProtos.InvokeResponse.html | 2 +- .../v1/CommonProtos.InvokeResponseOrBuilder.html | 2 +- docs/io/dapr/v1/CommonProtos.StateItem.Builder.html | 2 +- docs/io/dapr/v1/CommonProtos.StateItem.html | 2 +- docs/io/dapr/v1/CommonProtos.StateItemOrBuilder.html | 2 +- .../dapr/v1/CommonProtos.StateOptions.Builder.html | 2 +- .../CommonProtos.StateOptions.StateConcurrency.html | 2 +- .../CommonProtos.StateOptions.StateConsistency.html | 2 +- docs/io/dapr/v1/CommonProtos.StateOptions.html | 2 +- .../dapr/v1/CommonProtos.StateOptionsOrBuilder.html | 2 +- .../dapr/v1/CommonProtos.StreamPayload.Builder.html | 2 +- docs/io/dapr/v1/CommonProtos.StreamPayload.html | 2 +- .../dapr/v1/CommonProtos.StreamPayloadOrBuilder.html | 2 +- docs/io/dapr/v1/CommonProtos.html | 2 +- ...ppCallbackProtos.BindingEventRequest.Builder.html | 2 +- .../DaprAppCallbackProtos.BindingEventRequest.html | 2 +- ...pCallbackProtos.BindingEventRequestOrBuilder.html | 2 +- ...BindingEventResponse.BindingEventConcurrency.html | 2 +- ...pCallbackProtos.BindingEventResponse.Builder.html | 2 +- .../DaprAppCallbackProtos.BindingEventResponse.html | 2 +- ...CallbackProtos.BindingEventResponseOrBuilder.html | 2 +- ...ppCallbackProtos.BulkSubscribeConfig.Builder.html | 2 +- .../DaprAppCallbackProtos.BulkSubscribeConfig.html | 2 +- ...pCallbackProtos.BulkSubscribeConfigOrBuilder.html | 2 +- ...ppCallbackProtos.HealthCheckResponse.Builder.html | 2 +- .../DaprAppCallbackProtos.HealthCheckResponse.html | 2 +- ...pCallbackProtos.HealthCheckResponseOrBuilder.html | 2 +- ...aprAppCallbackProtos.JobEventRequest.Builder.html | 2 +- .../v1/DaprAppCallbackProtos.JobEventRequest.html | 2 +- ...prAppCallbackProtos.JobEventRequestOrBuilder.html | 2 +- ...prAppCallbackProtos.JobEventResponse.Builder.html | 2 +- .../v1/DaprAppCallbackProtos.JobEventResponse.html | 2 +- ...rAppCallbackProtos.JobEventResponseOrBuilder.html | 2 +- ...backProtos.ListInputBindingsResponse.Builder.html | 2 +- ...rAppCallbackProtos.ListInputBindingsResponse.html | 2 +- ...ackProtos.ListInputBindingsResponseOrBuilder.html | 2 +- ...rotos.ListTopicSubscriptionsResponse.Builder.html | 2 +- ...allbackProtos.ListTopicSubscriptionsResponse.html | 2 +- ...otos.ListTopicSubscriptionsResponseOrBuilder.html | 2 +- ...CallbackProtos.TopicEventBulkRequest.Builder.html | 2 +- .../DaprAppCallbackProtos.TopicEventBulkRequest.html | 2 +- ...ackProtos.TopicEventBulkRequestEntry.Builder.html | 2 +- ...kProtos.TopicEventBulkRequestEntry.EventCase.html | 2 +- ...AppCallbackProtos.TopicEventBulkRequestEntry.html | 2 +- ...ckProtos.TopicEventBulkRequestEntryOrBuilder.html | 2 +- ...allbackProtos.TopicEventBulkRequestOrBuilder.html | 2 +- ...allbackProtos.TopicEventBulkResponse.Builder.html | 2 +- ...DaprAppCallbackProtos.TopicEventBulkResponse.html | 2 +- ...ckProtos.TopicEventBulkResponseEntry.Builder.html | 2 +- ...ppCallbackProtos.TopicEventBulkResponseEntry.html | 2 +- ...kProtos.TopicEventBulkResponseEntryOrBuilder.html | 2 +- ...llbackProtos.TopicEventBulkResponseOrBuilder.html | 2 +- ...ppCallbackProtos.TopicEventCERequest.Builder.html | 2 +- .../DaprAppCallbackProtos.TopicEventCERequest.html | 2 +- ...pCallbackProtos.TopicEventCERequestOrBuilder.html | 2 +- ...rAppCallbackProtos.TopicEventRequest.Builder.html | 2 +- .../v1/DaprAppCallbackProtos.TopicEventRequest.html | 2 +- ...AppCallbackProtos.TopicEventRequestOrBuilder.html | 2 +- ...AppCallbackProtos.TopicEventResponse.Builder.html | 2 +- ....TopicEventResponse.TopicEventResponseStatus.html | 2 +- .../v1/DaprAppCallbackProtos.TopicEventResponse.html | 2 +- ...ppCallbackProtos.TopicEventResponseOrBuilder.html | 2 +- .../DaprAppCallbackProtos.TopicRoutes.Builder.html | 2 +- .../dapr/v1/DaprAppCallbackProtos.TopicRoutes.html | 2 +- .../DaprAppCallbackProtos.TopicRoutesOrBuilder.html | 2 +- .../v1/DaprAppCallbackProtos.TopicRule.Builder.html | 2 +- docs/io/dapr/v1/DaprAppCallbackProtos.TopicRule.html | 2 +- .../v1/DaprAppCallbackProtos.TopicRuleOrBuilder.html | 2 +- ...rAppCallbackProtos.TopicSubscription.Builder.html | 2 +- .../v1/DaprAppCallbackProtos.TopicSubscription.html | 2 +- ...AppCallbackProtos.TopicSubscriptionOrBuilder.html | 2 +- docs/io/dapr/v1/DaprAppCallbackProtos.html | 2 +- docs/io/dapr/v1/DaprGrpc.AsyncService.html | 2 +- docs/io/dapr/v1/DaprGrpc.DaprBlockingStub.html | 2 +- docs/io/dapr/v1/DaprGrpc.DaprFutureStub.html | 2 +- docs/io/dapr/v1/DaprGrpc.DaprImplBase.html | 2 +- docs/io/dapr/v1/DaprGrpc.DaprStub.html | 2 +- docs/io/dapr/v1/DaprGrpc.html | 2 +- .../dapr/v1/DaprProtos.ShutdownRequest.Builder.html | 2 +- docs/io/dapr/v1/DaprProtos.ShutdownRequest.html | 2 +- .../dapr/v1/DaprProtos.ShutdownRequestOrBuilder.html | 2 +- docs/io/dapr/v1/DaprProtos.html | 2 +- ...llbackAlphaGrpc.AppCallbackAlphaBlockingStub.html | 2 +- ...CallbackAlphaGrpc.AppCallbackAlphaFutureStub.html | 2 +- ...ppCallbackAlphaGrpc.AppCallbackAlphaImplBase.html | 2 +- .../AppCallbackAlphaGrpc.AppCallbackAlphaStub.html | 2 +- .../class-use/AppCallbackAlphaGrpc.AsyncService.html | 2 +- docs/io/dapr/v1/class-use/AppCallbackAlphaGrpc.html | 2 +- .../AppCallbackGrpc.AppCallbackBlockingStub.html | 2 +- .../AppCallbackGrpc.AppCallbackFutureStub.html | 2 +- .../AppCallbackGrpc.AppCallbackImplBase.html | 2 +- .../class-use/AppCallbackGrpc.AppCallbackStub.html | 2 +- .../v1/class-use/AppCallbackGrpc.AsyncService.html | 2 +- docs/io/dapr/v1/class-use/AppCallbackGrpc.html | 2 +- ...CheckGrpc.AppCallbackHealthCheckBlockingStub.html | 2 +- ...thCheckGrpc.AppCallbackHealthCheckFutureStub.html | 2 +- ...althCheckGrpc.AppCallbackHealthCheckImplBase.html | 2 +- ...ckHealthCheckGrpc.AppCallbackHealthCheckStub.html | 2 +- .../AppCallbackHealthCheckGrpc.AsyncService.html | 2 +- .../v1/class-use/AppCallbackHealthCheckGrpc.html | 2 +- .../CommonProtos.ConfigurationItem.Builder.html | 2 +- .../v1/class-use/CommonProtos.ConfigurationItem.html | 2 +- .../CommonProtos.ConfigurationItemOrBuilder.html | 2 +- .../dapr/v1/class-use/CommonProtos.Etag.Builder.html | 2 +- docs/io/dapr/v1/class-use/CommonProtos.Etag.html | 2 +- .../v1/class-use/CommonProtos.EtagOrBuilder.html | 2 +- .../CommonProtos.HTTPExtension.Builder.html | 2 +- .../class-use/CommonProtos.HTTPExtension.Verb.html | 2 +- .../v1/class-use/CommonProtos.HTTPExtension.html | 2 +- .../CommonProtos.HTTPExtensionOrBuilder.html | 2 +- .../CommonProtos.InvokeRequest.Builder.html | 2 +- .../v1/class-use/CommonProtos.InvokeRequest.html | 2 +- .../CommonProtos.InvokeRequestOrBuilder.html | 2 +- .../CommonProtos.InvokeResponse.Builder.html | 2 +- .../v1/class-use/CommonProtos.InvokeResponse.html | 2 +- .../CommonProtos.InvokeResponseOrBuilder.html | 2 +- .../v1/class-use/CommonProtos.StateItem.Builder.html | 2 +- .../io/dapr/v1/class-use/CommonProtos.StateItem.html | 2 +- .../class-use/CommonProtos.StateItemOrBuilder.html | 2 +- .../class-use/CommonProtos.StateOptions.Builder.html | 2 +- .../CommonProtos.StateOptions.StateConcurrency.html | 2 +- .../CommonProtos.StateOptions.StateConsistency.html | 2 +- .../dapr/v1/class-use/CommonProtos.StateOptions.html | 2 +- .../CommonProtos.StateOptionsOrBuilder.html | 2 +- .../CommonProtos.StreamPayload.Builder.html | 2 +- .../v1/class-use/CommonProtos.StreamPayload.html | 2 +- .../CommonProtos.StreamPayloadOrBuilder.html | 2 +- docs/io/dapr/v1/class-use/CommonProtos.html | 2 +- ...ppCallbackProtos.BindingEventRequest.Builder.html | 2 +- .../DaprAppCallbackProtos.BindingEventRequest.html | 2 +- ...pCallbackProtos.BindingEventRequestOrBuilder.html | 2 +- ...BindingEventResponse.BindingEventConcurrency.html | 2 +- ...pCallbackProtos.BindingEventResponse.Builder.html | 2 +- .../DaprAppCallbackProtos.BindingEventResponse.html | 2 +- ...CallbackProtos.BindingEventResponseOrBuilder.html | 2 +- ...ppCallbackProtos.BulkSubscribeConfig.Builder.html | 2 +- .../DaprAppCallbackProtos.BulkSubscribeConfig.html | 2 +- ...pCallbackProtos.BulkSubscribeConfigOrBuilder.html | 2 +- ...ppCallbackProtos.HealthCheckResponse.Builder.html | 2 +- .../DaprAppCallbackProtos.HealthCheckResponse.html | 2 +- ...pCallbackProtos.HealthCheckResponseOrBuilder.html | 2 +- ...aprAppCallbackProtos.JobEventRequest.Builder.html | 2 +- .../DaprAppCallbackProtos.JobEventRequest.html | 2 +- ...prAppCallbackProtos.JobEventRequestOrBuilder.html | 2 +- ...prAppCallbackProtos.JobEventResponse.Builder.html | 2 +- .../DaprAppCallbackProtos.JobEventResponse.html | 2 +- ...rAppCallbackProtos.JobEventResponseOrBuilder.html | 2 +- ...backProtos.ListInputBindingsResponse.Builder.html | 2 +- ...rAppCallbackProtos.ListInputBindingsResponse.html | 2 +- ...ackProtos.ListInputBindingsResponseOrBuilder.html | 2 +- ...rotos.ListTopicSubscriptionsResponse.Builder.html | 2 +- ...allbackProtos.ListTopicSubscriptionsResponse.html | 2 +- ...otos.ListTopicSubscriptionsResponseOrBuilder.html | 2 +- ...CallbackProtos.TopicEventBulkRequest.Builder.html | 2 +- .../DaprAppCallbackProtos.TopicEventBulkRequest.html | 2 +- ...ackProtos.TopicEventBulkRequestEntry.Builder.html | 2 +- ...kProtos.TopicEventBulkRequestEntry.EventCase.html | 2 +- ...AppCallbackProtos.TopicEventBulkRequestEntry.html | 2 +- ...ckProtos.TopicEventBulkRequestEntryOrBuilder.html | 2 +- ...allbackProtos.TopicEventBulkRequestOrBuilder.html | 2 +- ...allbackProtos.TopicEventBulkResponse.Builder.html | 2 +- ...DaprAppCallbackProtos.TopicEventBulkResponse.html | 2 +- ...ckProtos.TopicEventBulkResponseEntry.Builder.html | 2 +- ...ppCallbackProtos.TopicEventBulkResponseEntry.html | 2 +- ...kProtos.TopicEventBulkResponseEntryOrBuilder.html | 2 +- ...llbackProtos.TopicEventBulkResponseOrBuilder.html | 2 +- ...ppCallbackProtos.TopicEventCERequest.Builder.html | 2 +- .../DaprAppCallbackProtos.TopicEventCERequest.html | 2 +- ...pCallbackProtos.TopicEventCERequestOrBuilder.html | 2 +- ...rAppCallbackProtos.TopicEventRequest.Builder.html | 2 +- .../DaprAppCallbackProtos.TopicEventRequest.html | 2 +- ...AppCallbackProtos.TopicEventRequestOrBuilder.html | 2 +- ...AppCallbackProtos.TopicEventResponse.Builder.html | 2 +- ....TopicEventResponse.TopicEventResponseStatus.html | 2 +- .../DaprAppCallbackProtos.TopicEventResponse.html | 2 +- ...ppCallbackProtos.TopicEventResponseOrBuilder.html | 2 +- .../DaprAppCallbackProtos.TopicRoutes.Builder.html | 2 +- .../class-use/DaprAppCallbackProtos.TopicRoutes.html | 2 +- .../DaprAppCallbackProtos.TopicRoutesOrBuilder.html | 2 +- .../DaprAppCallbackProtos.TopicRule.Builder.html | 2 +- .../class-use/DaprAppCallbackProtos.TopicRule.html | 2 +- .../DaprAppCallbackProtos.TopicRuleOrBuilder.html | 2 +- ...rAppCallbackProtos.TopicSubscription.Builder.html | 2 +- .../DaprAppCallbackProtos.TopicSubscription.html | 2 +- ...AppCallbackProtos.TopicSubscriptionOrBuilder.html | 2 +- docs/io/dapr/v1/class-use/DaprAppCallbackProtos.html | 2 +- docs/io/dapr/v1/class-use/DaprGrpc.AsyncService.html | 2 +- .../dapr/v1/class-use/DaprGrpc.DaprBlockingStub.html | 2 +- .../dapr/v1/class-use/DaprGrpc.DaprFutureStub.html | 2 +- docs/io/dapr/v1/class-use/DaprGrpc.DaprImplBase.html | 2 +- docs/io/dapr/v1/class-use/DaprGrpc.DaprStub.html | 2 +- docs/io/dapr/v1/class-use/DaprGrpc.html | 2 +- .../DaprProtos.ShutdownRequest.Builder.html | 2 +- .../v1/class-use/DaprProtos.ShutdownRequest.html | 2 +- .../DaprProtos.ShutdownRequestOrBuilder.html | 2 +- docs/io/dapr/v1/class-use/DaprProtos.html | 2 +- docs/io/dapr/v1/package-summary.html | 2 +- docs/io/dapr/v1/package-tree.html | 2 +- docs/io/dapr/v1/package-use.html | 2 +- docs/io/dapr/workflows/Workflow.html | 2 +- docs/io/dapr/workflows/WorkflowContext.html | 2 +- docs/io/dapr/workflows/WorkflowStub.html | 2 +- docs/io/dapr/workflows/class-use/Workflow.html | 2 +- .../io/dapr/workflows/class-use/WorkflowContext.html | 2 +- docs/io/dapr/workflows/class-use/WorkflowStub.html | 2 +- .../io/dapr/workflows/client/DaprWorkflowClient.html | 2 +- .../workflows/client/WorkflowFailureDetails.html | 2 +- .../workflows/client/WorkflowInstanceStatus.html | 2 +- .../client/class-use/DaprWorkflowClient.html | 2 +- .../client/class-use/WorkflowFailureDetails.html | 2 +- .../client/class-use/WorkflowInstanceStatus.html | 2 +- docs/io/dapr/workflows/client/package-summary.html | 2 +- docs/io/dapr/workflows/client/package-tree.html | 2 +- docs/io/dapr/workflows/client/package-use.html | 2 +- .../internal/ApiTokenClientInterceptor.html | 2 +- .../class-use/ApiTokenClientInterceptor.html | 2 +- docs/io/dapr/workflows/internal/package-summary.html | 2 +- docs/io/dapr/workflows/internal/package-tree.html | 2 +- docs/io/dapr/workflows/internal/package-use.html | 2 +- docs/io/dapr/workflows/package-summary.html | 2 +- docs/io/dapr/workflows/package-tree.html | 2 +- docs/io/dapr/workflows/package-use.html | 2 +- docs/io/dapr/workflows/runtime/WorkflowRuntime.html | 2 +- .../workflows/runtime/WorkflowRuntimeBuilder.html | 2 +- .../workflows/runtime/class-use/WorkflowRuntime.html | 2 +- .../runtime/class-use/WorkflowRuntimeBuilder.html | 2 +- docs/io/dapr/workflows/runtime/package-summary.html | 2 +- docs/io/dapr/workflows/runtime/package-tree.html | 2 +- docs/io/dapr/workflows/runtime/package-use.html | 2 +- docs/overview-summary.html | 2 +- docs/overview-tree.html | 2 +- docs/project-reports.html | 6 +++--- docs/serialized-form.html | 2 +- 600 files changed, 611 insertions(+), 611 deletions(-) diff --git a/README.md b/README.md index 6dcd63497f..7ded8bb42f 100644 --- a/README.md +++ b/README.md @@ -69,19 +69,19 @@ For a Maven project, add the following to your `pom.xml` file: io.dapr dapr-sdk - 1.17.0 + 1.17.1 io.dapr dapr-sdk-actors - 1.17.0 + 1.17.1 io.dapr dapr-sdk-springboot - 1.17.0 + 1.17.1 ... @@ -95,11 +95,11 @@ For a Gradle project, add the following to your `build.gradle` file: dependencies { ... // Dapr's core SDK with all features, except Actors. - compile('io.dapr:dapr-sdk:1.17.0') + compile('io.dapr:dapr-sdk:1.17.1') // Dapr's SDK for Actors (optional). - compile('io.dapr:dapr-sdk-actors:1.17.0') + compile('io.dapr:dapr-sdk-actors:1.17.1') // Dapr's SDK integration with SpringBoot (optional). - compile('io.dapr:dapr-sdk-springboot:1.17.0') + compile('io.dapr:dapr-sdk-springboot:1.17.1') } ``` diff --git a/docs/allclasses-index.html b/docs/allclasses-index.html index c8c92b7c87..1cb3bed416 100644 --- a/docs/allclasses-index.html +++ b/docs/allclasses-index.html @@ -2,7 +2,7 @@ -All Classes and Interfaces (dapr-sdk-parent 1.17.0 API) +All Classes and Interfaces (dapr-sdk-parent 1.17.1 API) diff --git a/docs/allpackages-index.html b/docs/allpackages-index.html index d0d04475b7..73b4b3b93d 100644 --- a/docs/allpackages-index.html +++ b/docs/allpackages-index.html @@ -2,7 +2,7 @@ -All Packages (dapr-sdk-parent 1.17.0 API) +All Packages (dapr-sdk-parent 1.17.1 API) diff --git a/docs/constant-values.html b/docs/constant-values.html index 58b72a7c1b..09f8289e9c 100644 --- a/docs/constant-values.html +++ b/docs/constant-values.html @@ -2,7 +2,7 @@ -Constant Field Values (dapr-sdk-parent 1.17.0 API) +Constant Field Values (dapr-sdk-parent 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/allclasses-index.html b/docs/dapr-sdk-workflows/allclasses-index.html index e3bc60a33b..605245dfdb 100644 --- a/docs/dapr-sdk-workflows/allclasses-index.html +++ b/docs/dapr-sdk-workflows/allclasses-index.html @@ -2,7 +2,7 @@ -All Classes and Interfaces (dapr-sdk-workflows 1.17.0 API) +All Classes and Interfaces (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/allpackages-index.html b/docs/dapr-sdk-workflows/allpackages-index.html index 20fa2c5ebf..69dd5097bf 100644 --- a/docs/dapr-sdk-workflows/allpackages-index.html +++ b/docs/dapr-sdk-workflows/allpackages-index.html @@ -2,7 +2,7 @@ -All Packages (dapr-sdk-workflows 1.17.0 API) +All Packages (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/help-doc.html b/docs/dapr-sdk-workflows/help-doc.html index 6bebff778b..94a391d3bf 100644 --- a/docs/dapr-sdk-workflows/help-doc.html +++ b/docs/dapr-sdk-workflows/help-doc.html @@ -2,7 +2,7 @@ -API Help (dapr-sdk-workflows 1.17.0 API) +API Help (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/index-all.html b/docs/dapr-sdk-workflows/index-all.html index 720b89b4c6..f05223d5db 100644 --- a/docs/dapr-sdk-workflows/index-all.html +++ b/docs/dapr-sdk-workflows/index-all.html @@ -2,7 +2,7 @@ -Index (dapr-sdk-workflows 1.17.0 API) +Index (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/index.html b/docs/dapr-sdk-workflows/index.html index e4489fb042..08b53214a3 100644 --- a/docs/dapr-sdk-workflows/index.html +++ b/docs/dapr-sdk-workflows/index.html @@ -2,7 +2,7 @@ -Overview (dapr-sdk-workflows 1.17.0 API) +Overview (dapr-sdk-workflows 1.17.1 API) @@ -49,7 +49,7 @@
-

dapr-sdk-workflows 1.17.0 API

+

dapr-sdk-workflows 1.17.1 API

Packages
diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/Workflow.html b/docs/dapr-sdk-workflows/io/dapr/workflows/Workflow.html index b6056d1ca9..1c6b61a0f8 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/Workflow.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/Workflow.html @@ -2,7 +2,7 @@ -Workflow (dapr-sdk-workflows 1.17.0 API) +Workflow (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/WorkflowContext.html b/docs/dapr-sdk-workflows/io/dapr/workflows/WorkflowContext.html index 07c6bee533..1d4973cd12 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/WorkflowContext.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/WorkflowContext.html @@ -2,7 +2,7 @@ -WorkflowContext (dapr-sdk-workflows 1.17.0 API) +WorkflowContext (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/WorkflowStub.html b/docs/dapr-sdk-workflows/io/dapr/workflows/WorkflowStub.html index e561214333..e252cd2e63 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/WorkflowStub.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/WorkflowStub.html @@ -2,7 +2,7 @@ -WorkflowStub (dapr-sdk-workflows 1.17.0 API) +WorkflowStub (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/class-use/Workflow.html b/docs/dapr-sdk-workflows/io/dapr/workflows/class-use/Workflow.html index 051a813928..85e739d50b 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/class-use/Workflow.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/class-use/Workflow.html @@ -2,7 +2,7 @@ -Uses of Interface io.dapr.workflows.Workflow (dapr-sdk-workflows 1.17.0 API) +Uses of Interface io.dapr.workflows.Workflow (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/class-use/WorkflowContext.html b/docs/dapr-sdk-workflows/io/dapr/workflows/class-use/WorkflowContext.html index 9a3c40679c..725cac7757 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/class-use/WorkflowContext.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/class-use/WorkflowContext.html @@ -2,7 +2,7 @@ -Uses of Interface io.dapr.workflows.WorkflowContext (dapr-sdk-workflows 1.17.0 API) +Uses of Interface io.dapr.workflows.WorkflowContext (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/class-use/WorkflowStub.html b/docs/dapr-sdk-workflows/io/dapr/workflows/class-use/WorkflowStub.html index abb6a4b8e8..b92a947e77 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/class-use/WorkflowStub.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/class-use/WorkflowStub.html @@ -2,7 +2,7 @@ -Uses of Interface io.dapr.workflows.WorkflowStub (dapr-sdk-workflows 1.17.0 API) +Uses of Interface io.dapr.workflows.WorkflowStub (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/client/DaprWorkflowClient.html b/docs/dapr-sdk-workflows/io/dapr/workflows/client/DaprWorkflowClient.html index 16778612c4..56085d3e13 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/client/DaprWorkflowClient.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/client/DaprWorkflowClient.html @@ -2,7 +2,7 @@ -DaprWorkflowClient (dapr-sdk-workflows 1.17.0 API) +DaprWorkflowClient (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/client/WorkflowFailureDetails.html b/docs/dapr-sdk-workflows/io/dapr/workflows/client/WorkflowFailureDetails.html index c08488f82b..f26a654f04 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/client/WorkflowFailureDetails.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/client/WorkflowFailureDetails.html @@ -2,7 +2,7 @@ -WorkflowFailureDetails (dapr-sdk-workflows 1.17.0 API) +WorkflowFailureDetails (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/client/WorkflowInstanceStatus.html b/docs/dapr-sdk-workflows/io/dapr/workflows/client/WorkflowInstanceStatus.html index 5d659602ea..73eb64d9f7 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/client/WorkflowInstanceStatus.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/client/WorkflowInstanceStatus.html @@ -2,7 +2,7 @@ -WorkflowInstanceStatus (dapr-sdk-workflows 1.17.0 API) +WorkflowInstanceStatus (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/client/class-use/DaprWorkflowClient.html b/docs/dapr-sdk-workflows/io/dapr/workflows/client/class-use/DaprWorkflowClient.html index 869f2acdcb..f8c8909871 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/client/class-use/DaprWorkflowClient.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/client/class-use/DaprWorkflowClient.html @@ -2,7 +2,7 @@ -Uses of Class io.dapr.workflows.client.DaprWorkflowClient (dapr-sdk-workflows 1.17.0 API) +Uses of Class io.dapr.workflows.client.DaprWorkflowClient (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/client/class-use/WorkflowFailureDetails.html b/docs/dapr-sdk-workflows/io/dapr/workflows/client/class-use/WorkflowFailureDetails.html index 155fe88c87..f81ca800df 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/client/class-use/WorkflowFailureDetails.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/client/class-use/WorkflowFailureDetails.html @@ -2,7 +2,7 @@ -Uses of Interface io.dapr.workflows.client.WorkflowFailureDetails (dapr-sdk-workflows 1.17.0 API) +Uses of Interface io.dapr.workflows.client.WorkflowFailureDetails (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/client/class-use/WorkflowInstanceStatus.html b/docs/dapr-sdk-workflows/io/dapr/workflows/client/class-use/WorkflowInstanceStatus.html index 442c41b8fa..6eefd8c5a9 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/client/class-use/WorkflowInstanceStatus.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/client/class-use/WorkflowInstanceStatus.html @@ -2,7 +2,7 @@ -Uses of Interface io.dapr.workflows.client.WorkflowInstanceStatus (dapr-sdk-workflows 1.17.0 API) +Uses of Interface io.dapr.workflows.client.WorkflowInstanceStatus (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/client/package-summary.html b/docs/dapr-sdk-workflows/io/dapr/workflows/client/package-summary.html index e92cea89b9..7c05c63884 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/client/package-summary.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/client/package-summary.html @@ -2,7 +2,7 @@ -io.dapr.workflows.client (dapr-sdk-workflows 1.17.0 API) +io.dapr.workflows.client (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/client/package-tree.html b/docs/dapr-sdk-workflows/io/dapr/workflows/client/package-tree.html index 44532ecc89..e5ac1e2ae9 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/client/package-tree.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/client/package-tree.html @@ -2,7 +2,7 @@ -io.dapr.workflows.client Class Hierarchy (dapr-sdk-workflows 1.17.0 API) +io.dapr.workflows.client Class Hierarchy (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/client/package-use.html b/docs/dapr-sdk-workflows/io/dapr/workflows/client/package-use.html index 1e0038e467..203f6ae68d 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/client/package-use.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/client/package-use.html @@ -2,7 +2,7 @@ -Uses of Package io.dapr.workflows.client (dapr-sdk-workflows 1.17.0 API) +Uses of Package io.dapr.workflows.client (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/internal/ApiTokenClientInterceptor.html b/docs/dapr-sdk-workflows/io/dapr/workflows/internal/ApiTokenClientInterceptor.html index f0cad66957..1c48aadcad 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/internal/ApiTokenClientInterceptor.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/internal/ApiTokenClientInterceptor.html @@ -2,7 +2,7 @@ -ApiTokenClientInterceptor (dapr-sdk-workflows 1.17.0 API) +ApiTokenClientInterceptor (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/internal/class-use/ApiTokenClientInterceptor.html b/docs/dapr-sdk-workflows/io/dapr/workflows/internal/class-use/ApiTokenClientInterceptor.html index 4bec6cca56..df51018c71 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/internal/class-use/ApiTokenClientInterceptor.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/internal/class-use/ApiTokenClientInterceptor.html @@ -2,7 +2,7 @@ -Uses of Class io.dapr.workflows.internal.ApiTokenClientInterceptor (dapr-sdk-workflows 1.17.0 API) +Uses of Class io.dapr.workflows.internal.ApiTokenClientInterceptor (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/internal/package-summary.html b/docs/dapr-sdk-workflows/io/dapr/workflows/internal/package-summary.html index 5e0db98034..5476a94690 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/internal/package-summary.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/internal/package-summary.html @@ -2,7 +2,7 @@ -io.dapr.workflows.internal (dapr-sdk-workflows 1.17.0 API) +io.dapr.workflows.internal (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/internal/package-tree.html b/docs/dapr-sdk-workflows/io/dapr/workflows/internal/package-tree.html index 30922f97e0..63ed7cf306 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/internal/package-tree.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/internal/package-tree.html @@ -2,7 +2,7 @@ -io.dapr.workflows.internal Class Hierarchy (dapr-sdk-workflows 1.17.0 API) +io.dapr.workflows.internal Class Hierarchy (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/internal/package-use.html b/docs/dapr-sdk-workflows/io/dapr/workflows/internal/package-use.html index 7d08f0f2c0..cf8c60ed7d 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/internal/package-use.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/internal/package-use.html @@ -2,7 +2,7 @@ -Uses of Package io.dapr.workflows.internal (dapr-sdk-workflows 1.17.0 API) +Uses of Package io.dapr.workflows.internal (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/package-summary.html b/docs/dapr-sdk-workflows/io/dapr/workflows/package-summary.html index 34448e038e..67f6e5b0ad 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/package-summary.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/package-summary.html @@ -2,7 +2,7 @@ -io.dapr.workflows (dapr-sdk-workflows 1.17.0 API) +io.dapr.workflows (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/package-tree.html b/docs/dapr-sdk-workflows/io/dapr/workflows/package-tree.html index a7a05b2f84..b449a1dfb2 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/package-tree.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/package-tree.html @@ -2,7 +2,7 @@ -io.dapr.workflows Class Hierarchy (dapr-sdk-workflows 1.17.0 API) +io.dapr.workflows Class Hierarchy (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/package-use.html b/docs/dapr-sdk-workflows/io/dapr/workflows/package-use.html index 9c70de6bfd..4a77db3d01 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/package-use.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/package-use.html @@ -2,7 +2,7 @@ -Uses of Package io.dapr.workflows (dapr-sdk-workflows 1.17.0 API) +Uses of Package io.dapr.workflows (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/WorkflowRuntime.html b/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/WorkflowRuntime.html index 207a60b8f4..e29ebd39ae 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/WorkflowRuntime.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/WorkflowRuntime.html @@ -2,7 +2,7 @@ -WorkflowRuntime (dapr-sdk-workflows 1.17.0 API) +WorkflowRuntime (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/WorkflowRuntimeBuilder.html b/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/WorkflowRuntimeBuilder.html index dac74c5254..6f82732e4b 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/WorkflowRuntimeBuilder.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/WorkflowRuntimeBuilder.html @@ -2,7 +2,7 @@ -WorkflowRuntimeBuilder (dapr-sdk-workflows 1.17.0 API) +WorkflowRuntimeBuilder (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/class-use/WorkflowRuntime.html b/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/class-use/WorkflowRuntime.html index 5d28871dad..9b00b3af77 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/class-use/WorkflowRuntime.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/class-use/WorkflowRuntime.html @@ -2,7 +2,7 @@ -Uses of Class io.dapr.workflows.runtime.WorkflowRuntime (dapr-sdk-workflows 1.17.0 API) +Uses of Class io.dapr.workflows.runtime.WorkflowRuntime (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/class-use/WorkflowRuntimeBuilder.html b/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/class-use/WorkflowRuntimeBuilder.html index 7304161475..f9bc6d7f33 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/class-use/WorkflowRuntimeBuilder.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/class-use/WorkflowRuntimeBuilder.html @@ -2,7 +2,7 @@ -Uses of Class io.dapr.workflows.runtime.WorkflowRuntimeBuilder (dapr-sdk-workflows 1.17.0 API) +Uses of Class io.dapr.workflows.runtime.WorkflowRuntimeBuilder (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/package-summary.html b/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/package-summary.html index cd5aa01815..6c0cfd3e6d 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/package-summary.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/package-summary.html @@ -2,7 +2,7 @@ -io.dapr.workflows.runtime (dapr-sdk-workflows 1.17.0 API) +io.dapr.workflows.runtime (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/package-tree.html b/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/package-tree.html index 984433d7a3..2b69e665e0 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/package-tree.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/package-tree.html @@ -2,7 +2,7 @@ -io.dapr.workflows.runtime Class Hierarchy (dapr-sdk-workflows 1.17.0 API) +io.dapr.workflows.runtime Class Hierarchy (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/package-use.html b/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/package-use.html index 9b8ecdfed3..98ecaba216 100644 --- a/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/package-use.html +++ b/docs/dapr-sdk-workflows/io/dapr/workflows/runtime/package-use.html @@ -2,7 +2,7 @@ -Uses of Package io.dapr.workflows.runtime (dapr-sdk-workflows 1.17.0 API) +Uses of Package io.dapr.workflows.runtime (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/overview-summary.html b/docs/dapr-sdk-workflows/overview-summary.html index 3c5763540c..05fd58196f 100644 --- a/docs/dapr-sdk-workflows/overview-summary.html +++ b/docs/dapr-sdk-workflows/overview-summary.html @@ -2,7 +2,7 @@ -dapr-sdk-workflows 1.17.0 API +dapr-sdk-workflows 1.17.1 API diff --git a/docs/dapr-sdk-workflows/overview-tree.html b/docs/dapr-sdk-workflows/overview-tree.html index 3b120d41af..db8e31ca6f 100644 --- a/docs/dapr-sdk-workflows/overview-tree.html +++ b/docs/dapr-sdk-workflows/overview-tree.html @@ -2,7 +2,7 @@ -Class Hierarchy (dapr-sdk-workflows 1.17.0 API) +Class Hierarchy (dapr-sdk-workflows 1.17.1 API) diff --git a/docs/dapr-sdk-workflows/project-reports.html b/docs/dapr-sdk-workflows/project-reports.html index d9a845c3c6..f79533ef14 100644 --- a/docs/dapr-sdk-workflows/project-reports.html +++ b/docs/dapr-sdk-workflows/project-reports.html @@ -1,6 +1,6 @@ @@ -25,8 +25,8 @@