cleaning up names

Author: salaboy

tutorials/workflow/java/task-chaining/README.md

@@ -0,0 +1,68 @@
+# Task Chaining Pattern
+
+This tutorial demonstrates how to chain multiple tasks together as a sequence in a workflow. For more information about the task chaining pattern see the [Dapr docs](https://docs.dapr.io/developing-applications/building-blocks/workflow/workflow-patterns/#task-chaining).
+
+## Inspect the code
+
+Open the `ChainingWorkflow.java` file in the `tutorials/workflow/java/task-chaining/src/main/java/io/dapr/springboot/examples/wfp/chain` folder. This file contains the definition for the workflow.
+
+```mermaid
+graph LR
+   SW((Start
+   Workflow))
+   A1[Activity1]
+   A2[Activity2]
+   A3[Activity3]
+   EW((End
+   Workflow))
+   SW --> A1
+   A1 --> A2
+   A2 --> A3
+   A3 --> EW
+```
+
+
+## Run the tutorial
+
+1. Use a terminal to navigate to the `tutorials/workflow/java/task-chaining` folder.
+2. Build and run the project using Maven.
+
+    ```bash
+    mvn spring-boot:test-run
+    ```
+
+3Use the POST request in the [`chaining.http`](./chaining.http) file to start the workflow, or use this cURL command:
+
+    ```bash
+    curl -i --request POST http://localhost:8080/start
+    ```
+
+   The input for the workflow is a string with the value `This`. The expected app logs are as follows:
+
+    ```text
+    == APP - chaining == Activity1: Received input: This.
+    == APP - chaining == Activity2: Received input: This is.
+    == APP - chaining == Activity3: Received input: This is task.
+    ```
+
+5. Use the GET request in the [`chaining.http`](./chaining.http) file to get the status of the workflow, or use this cURL command:
+
+    ```bash
+    curl --request GET --url http://localhost:<DAPR_PORT>/v1.0/workflows/dapr/<INSTANCEID>
+    ```
+
+   Where `<INSTANCEID>` is the workflow instance ID you received in the `Location` header in the previous step.
+   Where `<DAPR_PORT>` can be obtained by looking at the port mappings created by Testcontainers when running the application. 
+   You can find this by running `docker ps` and looking at the port-mappings 
+   ```bash
+   CONTAINER ID   IMAGE                               COMMAND                  CREATED          STATUS          PORTS                                                                     NAMES
+   bc19a46794e1   daprio/daprd:1.15.4                 "./daprd --app-id wo…"   48 seconds ago   Up 48 seconds   0.0.0.0:61693->3500/tcp, 0.0.0.0:61694->50001/tcp
+   ```
+   For this example: `61693` which was mapped to the Dapr port `3500` (`0.0.0.0:61693->3500/tcp`).
+6. The expected serialized output of the workflow is:
+
+    ```txt
+    "\"This is task chaining\""
+    ```
+
+6. Stop the application by pressing `Ctrl+C`.

tutorials/workflow/java/task-chaining/chaining.http

@@ -0,0 +1,11 @@
+@apphost=http://localhost:5255
+
+### Start the TaskChaining workflow
+# @name startWorkflowRequest
+POST {{ apphost }}/start
+
+
+@instanceId={{startWorkflowRequest.response.headers.Location}}
+@daprHost=http://localhost:3555
+### Get the workflow status
+GET {{ daprHost }}/v1.0/workflows/dapr/{{ instanceId }}

tutorials/workflow/java/task-chaining/pom.xml

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-parent</artifactId>
+    <version>3.4.5</version>
+    <relativePath/> <!-- lookup parent from repository -->
+  </parent>
+
+  <artifactId>task-chaining</artifactId>
+  <name>task-chaining</name>
+  <description>Task Chaining Workflow Example</description>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-actuator</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-web</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-test</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.dapr.spring</groupId>
+      <artifactId>dapr-spring-boot-starter</artifactId>
+      <version>0.15.0-rc-5</version>
+    </dependency>
+    <dependency>
+      <groupId>io.dapr.spring</groupId>
+      <artifactId>dapr-spring-boot-starter-test</artifactId>
+      <version>0.15.0-rc-5</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>io.rest-assured</groupId>
+      <artifactId>rest-assured</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-maven-plugin</artifactId>
+      </plugin>
+    </plugins>
+  </build>
+</project>

tutorials/workflow/java/task-chaining/src/main/java/io/dapr/springboot/examples/TaskChainingApplication.java

@@ -0,0 +1,27 @@
+/*
+ * 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;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+
+@SpringBootApplication
+public class TaskChainingApplication {
+
+  public static void main(String[] args) {
+    SpringApplication.run(TaskChainingApplication.class, args);
+  }
+
+}

tutorials/workflow/java/task-chaining/src/main/java/io/dapr/springboot/examples/TaskChainingConfiguration.java

@@ -0,0 +1,34 @@
+/*
+ * 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;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.client.RestTemplate;
+
+@Configuration
+public class TaskChainingConfiguration {
+
+  @Bean
+  public RestTemplate restTemplate() {
+    return new RestTemplateBuilder().build();
+  }
+
+  @Bean
+  public ObjectMapper mapper() {
+    return new ObjectMapper();
+  }
+}

tutorials/workflow/java/task-chaining/src/main/java/io/dapr/springboot/examples/TaskChainingRestController.java

@@ -0,0 +1,51 @@
+/*
+ * 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;
+
+
+import io.dapr.spring.workflows.config.EnableDaprWorkflows;
+import io.dapr.springboot.examples.chain.ChainWorkflow;
+import io.dapr.workflows.client.DaprWorkflowClient;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.concurrent.TimeoutException;
+
+@RestController
+@EnableDaprWorkflows
+public class TaskChainingRestController {
+
+  private final Logger logger = LoggerFactory.getLogger(TaskChainingRestController.class);
+
+  @Autowired
+  private DaprWorkflowClient daprWorkflowClient;
+
+
+  /**
+   * Run Chain Demo Workflow
+   * @return the output of the ChainWorkflow execution
+   */
+  @PostMapping("start")
+  public String chain() throws TimeoutException {
+    String instanceId = daprWorkflowClient.scheduleNewWorkflow(ChainWorkflow.class, "This");
+    return instanceId;
+  }
+
+
+
+
+}

tutorials/workflow/java/task-chaining/src/main/java/io/dapr/springboot/examples/chain/Activity1.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2023 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.chain;
+
+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 Activity1 implements WorkflowActivity {
+
+  @Override
+  public Object run(WorkflowActivityContext ctx) {
+    Logger logger = LoggerFactory.getLogger(Activity1.class);
+    var input = ctx.getInput(String.class);
+    logger.info(ctx.getName() + " : Received input: " + input);
+    return input + " is";
+  }
+}

tutorials/workflow/java/task-chaining/src/main/java/io/dapr/springboot/examples/chain/Activity2.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2023 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.chain;
+
+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 Activity2 implements WorkflowActivity {
+
+  @Override
+  public Object run(WorkflowActivityContext ctx) {
+    Logger logger = LoggerFactory.getLogger(Activity2.class);
+    var input = ctx.getInput(String.class);
+    logger.info(ctx.getName() + " : Received input: " + input);
+    return input + " task";
+  }
+}

tutorials/workflow/java/task-chaining/src/main/java/io/dapr/springboot/examples/chain/Activity3.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2023 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.chain;
+
+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 Activity3 implements WorkflowActivity {
+
+  @Override
+  public Object run(WorkflowActivityContext ctx) {
+    Logger logger = LoggerFactory.getLogger(Activity3.class);
+    var input = ctx.getInput(String.class);
+    logger.info(ctx.getName() + " : Received input: " + input);
+    return input + " chaining";
+  }
+}

tutorials/workflow/java/task-chaining/src/main/java/io/dapr/springboot/examples/chain/ChainWorkflow.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2023 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.chain;
+
+import io.dapr.workflows.Workflow;
+import io.dapr.workflows.WorkflowStub;
+import org.springframework.stereotype.Component;
+
+@Component
+public class ChainWorkflow implements Workflow {
+  @Override
+  public WorkflowStub create() {
+    return ctx -> {
+      ctx.getLogger().info("Starting Workflow: " + ctx.getName());
+
+      var input = ctx.getInput(String.class);
+      String result = ctx.callActivity(Activity1.class.getName(), input, String.class).await();
+      result = ctx.callActivity(Activity2.class.getName(), result, String.class).await();
+      result = ctx.callActivity(Activity3.class.getName(), result, String.class).await();
+
+      ctx.complete(result);
+    };
+  }
+}