### Conductor Server and UI Setup

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/clientsdks/python-sdk.md

Commands to clone the Conductor repository, start the server using Gradle, and start the UI using Yarn.

```bash
$ git clone https://github.com/conductor-oss/conductor.git
$ cd conductor/
$ ./gradlew bootRun

$ cd ui/
$ yarn install
$ yarn run start
```

--------------------------------

### Start Workflow using Node Fetch

Source: https://github.com/conductor-oss/conductor/blob/main/docs/devguide/how-tos/Workflows/starting-workflows.md

An example of starting a workflow named 'sample_workflow' with a JSON payload using Node.js fetch. It demonstrates setting headers and the request body.

```javascript
fetch("{{ server_host }}{{ api_prefix }}/workflow/sample_workflow", {
    "headers": {
        "accept": "text/plain",
        "content-type": "application/json",
    },
    "body": "{\"service\":\"fedex\"}",
    "method": "POST",
});
```

--------------------------------

### Start Workflow using curl

Source: https://github.com/conductor-oss/conductor/blob/main/docs/devguide/how-tos/Workflows/starting-workflows.md

An example of starting a workflow named 'sample_workflow' with a JSON payload containing a 'service' parameter using curl.

```bash
curl '{{ server_host }}{{ api_prefix }}/workflow/sample_workflow' \
  -H 'accept: text/plain' \
  -H 'content-type: application/json' \
  --data-raw '{"service":"fedex"}'
```

--------------------------------

### Start Conductor with Docker Compose

Source: https://github.com/conductor-oss/conductor/blob/main/README.md

This command initiates Conductor services using Docker Compose. It's the recommended method for local deployment and requires Docker Desktop to be installed.

```shell
docker compose -f docker/docker-compose.yaml up
```

--------------------------------

### Basic Workflow Start Payload Example

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/api/startworkflow.md

A JavaScript object demonstrating the payload structure for starting a Conductor workflow. It includes essential fields like workflow name, version, correlation ID, priority, and input parameters.

```javascript
{
  "name": "myWorkflow", // Name of the workflow
  "version": 1, // Version
  "correlationId": "corr1", // Correlation Id
  "priority": 1, // Priority
    "input": { // Input Value Map
      "param1": "value1",
      "param2": "value2"
    },
  "taskToDomain": {
	// Task to domain map
  }
}
```

--------------------------------

### HTTP GET Method Example

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/configuration/workflowdef/systemtasks/http-task.md

An example of configuring an HTTP task to perform a GET request, demonstrating the use of variables within the URI.

```json
{
  "name": "Get Example",
  "taskReferenceName": "get_example",
  "inputParameters": {
    "http_request": {
      "uri": "https://jsonplaceholder.typicode.com/posts/${workflow.input.queryid}",
      "method": "GET"
    }
  },
  "type": "HTTP"
}
```

--------------------------------

### Build from Source Guide Reference

Source: https://github.com/conductor-oss/conductor/blob/main/README.md

Reference to the guide for building Conductor from source. This process involves configuring databases, queues, and environment settings for a standalone Java application deployment.

```md
Follow the **[Building Conductor From Source](docs/devguide/running/source.md)** guide included in this repo.
```

--------------------------------

### Install UI Dependencies

Source: https://github.com/conductor-oss/conductor/blob/main/docs/devguide/running/source.md

Installs the necessary package dependencies for the Conductor UI using Yarn. This command should be run from the `/ui` directory.

```shell
cd conductor/ui
ui $ yarn install
```

--------------------------------

### Register Task and Workflow Definitions, Start Workflow

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/clientsdks/csharp-sdk.md

Provides a comprehensive example of registering a task definition, defining a workflow, and initiating its execution using the Conductor SDK. It covers setting up configuration, metadata API, workflow resource API, and task/workflow parameters.

```csharp
IDictionary<string, string> optionalHeaders = new ConcurrentDictionary<string, string>();
Configuration configuration = new Configuration(optionalHeaders, "keyId", "keySecret");

//Create task definition
MetadataResourceApi metadataResourceApi = new MetadataResourceApi(configuration);
TaskDef taskDef = new TaskDef(name: "test_task");
taskDef.OwnerEmail = "test@test.com";
metadataResourceApi.RegisterTaskDef(new List<TaskDef>() { taskDef});

//Create workflow definition
WorkflowDef workflowDef = new WorkflowDef();
workflowDef.Name = "test_workflow";
workflowDef.OwnerEmail = "test@test.com";
workflowDef.SchemaVersion = 2;

WorkflowTask workflowTask = new WorkflowTask();
workflowTask.Type = "HTTP";
workflowTask.Name = "test_"; //Same as registered task definition.
IDictionary<string, string> requestParams = new Dictionary<string, string>();
requestParams.Add("uri", "https://www.google.com"); //adding a key/value using the Add() method
requestParams.Add("method", "GET");
Dictionary<string, object> request = new Dictionary<string, object>();
request.Add("http_request", requestParams);
workflowTask.InputParameters = request;
workflowDef.Tasks = new List<WorkflowTask>() { workflowTask };
//Run a workflow
WorkflowResourceApi workflowResourceApi = new WorkflowResourceApi(configuration);
Dictionary<string, Object> input = new Dictionary<string, Object>();
//Fill the input map which workflow consumes.
workflowResourceApi.StartWorkflow("test_workflow", input, 1);
Console.ReadLine();
```

--------------------------------

### Starting Conductor Task Handler

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/clientsdks/python-sdk.md

Sets up the Conductor client configuration, defines workers, and starts the `TaskHandler` to poll and execute tasks.

```python
from conductor.client.automator.task_handler import TaskHandler
from conductor.client.configuration.configuration import Configuration
from conductor.client.worker.sample.faulty_execution_worker import FaultyExecutionWorker
from conductor.client.worker.sample.simple_python_worker import SimplePythonWorker

def main():
    configuration = Configuration(debug=True)
    task_definition_name = 'python_example_task'
    workers = [
        SimplePythonWorker(task_definition_name),
        FaultyExecutionWorker(task_definition_name)
    ]
    with TaskHandler(workers, configuration) as task_handler:
        task_handler.start()

if __name__ == '__main__':
    main()
```

--------------------------------

### Virtual Environment Setup

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/clientsdks/python-sdk.md

Commands to create and activate a Python virtual environment.

```bash
$ virtualenv conductor
$ source conductor/bin/activate
```

--------------------------------

### Clone Conductor Repository

Source: https://github.com/conductor-oss/conductor/blob/main/README.md

This snippet shows how to clone the Conductor GitHub repository to your local machine using Git. This is the first step to getting started with Conductor.

```shell
git clone https://github.com/conductor-oss/conductor
```

--------------------------------

### Install Conductor Python SDK

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/clientsdks/python-sdk.md

Command to install the latest version of the `conductor-python` package using pip.

```bash
$ python3 -m pip install conductor-python
```

--------------------------------

### Starting Conductor Workflow Execution and Waiting - Java

Source: https://github.com/conductor-oss/conductor/blob/main/conductor-clients/java/conductor-java-sdk/sdk/workflow_sdk.md

This code shows how to initiate an execution of a registered Conductor workflow with provided inputs using the execute() method. It returns a CompletableFuture for asynchronous handling, but the example also demonstrates how to block and wait for the workflow to complete using .get().

```java
//Returns a completable future
CompletableFuture<Workflow> execution = conductorWorkflow.execute(input);

//Wait for the workflow to complete -- useful if workflow completes within a reasonable amount of time
Workflow workflowRun = execution.get();

//Get the workflowId
String workflowId = workflowRun.getWorkflowId();

//Get the status of workflow execution
WorkflowStatus status = workflowRun.getStatus();
```

--------------------------------

### Install UI Dependencies

Source: https://github.com/conductor-oss/conductor/blob/main/ui/README.md

Installs the necessary package dependencies for the Conductor UI using Yarn. This command should be run from within the `/ui` directory.

```bash
cd ui
yarn install
```

--------------------------------

### Start Workflow Execution - Java

Source: https://github.com/conductor-oss/conductor/blob/main/conductor-clients/java/conductor-java-sdk/conductor-client/README.md

Demonstrates how to use the `WorkflowClient` (created from a `ConductorClient` instance) to start a workflow. It requires a `StartWorkflowRequest` specifying the workflow name and version. The method returns the ID of the newly started workflow instance. Requires a running Conductor server and a registered workflow definition.

```Java
import com.netflix.conductor.client.http.ConductorClient;
import com.netflix.conductor.client.http.WorkflowClient;
import com.netflix.conductor.common.metadata.workflow.StartWorkflowRequest;

// … other code
var client = new ConductorClient("http://localhost:8080/api");
var workflowClient = new WorkflowClient(client);
var workflowId = workflowClient.startWorkflow(new StartWorkflowRequest()
        .withName("hello_workflow")
        .withVersion(1));

System.out.println("Started workflow " + workflowId);
```

--------------------------------

### Start Workflow Execution

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/clientsdks/python-sdk.md

API call to start a new instance of a workflow.

```APIDOC
POST /actions/{{workflow_name}}/{{version}}
```

--------------------------------

### Protobuf Definition for Example Message

Source: https://github.com/conductor-oss/conductor/blob/main/annotations-processor/src/test/resources/example.proto.txt

Defines the 'Example' message structure using Protobuf version 3. This message includes a 'name' field of type string and a 'count' field of type int64. It also specifies Java and Go package options.

```proto
syntax = "proto3";
package protoPackage;


option java_package = "abc.protogen.example";
option java_outer_classname = "ExamplePb";
option go_package = "goPackage";

message Example {
    string name = 1;
    int64 count = 2;
}
```

--------------------------------

### Start Conductor with PostgreSQL

Source: https://github.com/conductor-oss/conductor/blob/main/docs/devguide/running/docker.md

Starts Conductor using a Docker Compose configuration that utilizes PostgreSQL as the persistence store.

```shell
conductor $ docker compose -f docker/docker-compose-postgres.yaml up
```

--------------------------------

### Start Workflow API Documentation

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/api/startworkflow.md

Details the parameters for starting a workflow execution via the Conductor API. It specifies the 'name', 'version', 'input', 'correlationId', 'taskToDomain', 'workflowDef', 'externalInputPayloadStoragePath', and 'priority' fields, along with their descriptions and notes. The output on success is the workflow ID.

```APIDOC
Start Workflow API:

API Parameters:
When starting a Workflow execution with a registered definition, `/workflow` accepts following parameters in the `POST` payload:

- name: Name of the Workflow. MUST be registered with Conductor before starting workflow
- version: Workflow version (defaults to latest available version)
- input: JSON object with key value params, that can be used by downstream tasks. See [Wiring Inputs and Outputs](../configuration/workflowdef/index.md#wiring-inputs-and-outputs) for details.
- correlationId: Unique Id that correlates multiple Workflow executions (optional)
- taskToDomain: See [Task Domains](taskdomains.md) for more information (optional)
- workflowDef: An adhoc [Workflow Definition](../configuration/workflowdef/index.md) to run, without registering. See [Dynamic Workflows](#dynamic-workflows) (optional)
- externalInputPayloadStoragePath: This is taken care of by Java client. See [External Payload Storage](../advanced/externalpayloadstorage.md) for more info (optional)
- priority: Priority level for the tasks within this workflow execution. Possible values are between 0 - 99 (optional)

Output:
On success, this API returns the ID of the workflow.

Basic Example:
`POST {{ server_host }}{{ api_prefix }}/workflow` with payload body:

```js
{
  "name": "myWorkflow", // Name of the workflow
  "version": 1, // Version
  "correlationId": "corr1", // Correlation Id
  "priority": 1, // Priority
    "input": { // Input Value Map
      "param1": "value1",
      "param2": "value2"
    },
  "taskToDomain": {
	// Task to domain map
  }
}
```
```

--------------------------------

### Task Configuration Example (shipping_info)

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/configuration/workflowdef/operators/dynamic-task.md

An example configuration for a 'SIMPLE' task named 'shipping_info'. This task is expected to output the name of the shipping service to be used.

```json
{
  "name": "shipping_info",
  "retryCount": 3,
  "timeoutSeconds": 600,
  "pollTimeoutSeconds": 1200,
  "timeoutPolicy": "TIME_OUT_WF",
  "retryLogic": "FIXED",
  "retryDelaySeconds": 300,
  "responseTimeoutSeconds": 300,
  "concurrentExecLimit": 100,
  "rateLimitFrequencyInSeconds": 60,
  "ownerEmail":"abc@example.com",
  "rateLimitPerFrequency": 1
}
```

--------------------------------

### Initializing and Starting Workers with WorkflowExecutor (Java)

Source: https://github.com/conductor-oss/conductor/blob/main/conductor-clients/java/conductor-java-sdk/sdk/worker_sdk.md

Shows the basic steps to initialize the `WorkflowExecutor` by providing the Conductor API server URL. It then demonstrates starting the workers by calling `initWorkers` and specifying a comma-separated list of Java packages to scan for methods annotated with `@WorkerTask`. Worker methods must be public and their containing classes must have a no-args constructor.

```Java
WorkflowExecutor executor = new WorkflowExecutor("http://server/api/");
//List of packages  (comma separated) to scan for annotated workers.  
// Please note, the worker method MUST be public and the class in which they are defined
//MUST have a no-args constructor        
executor.initWorkers("com.company.package1,com.company.package2");
```

--------------------------------

### Setup conductor-go Package

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/clientsdks/go-sdk.md

Commands to initialize a new Go module and fetch the Conductor Go SDK. This is the first step in setting up the Go SDK for use in a project.

```shell
mkdir quickstart/
cd quickstart/
go mod init quickstart

go get github.com/conductor-oss/go-sdk
```

--------------------------------

### Setting Up Logging - logrus Go

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/clientsdks/go-sdk.md

This Go function demonstrates how to configure the logrus logging library, which is used by the Conductor Go SDK. It sets the log format, output destination (stdout), and the minimum logging level.

```go
func init() {
	log.SetFormatter(&log.TextFormatter{})
	log.SetOutput(os.Stdout)
	log.SetLevel(log.DebugLevel)
}
```

--------------------------------

### Event Handler Actions: Start Workflow

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/configuration/eventhandlers.md

An example of an action configuration to start a new workflow when an event is triggered. It specifies the workflow name, version, and input parameters, which can be dynamically populated using expressions.

```json
{
    "action": "start_workflow",
    "start_workflow": {
        "name": "WORKFLOW_NAME",
        "version": "<optional_param>",
        "input": {
            "param1": "${param1}" 
        }
    }
}
```

--------------------------------

### Java Client: Start Workflow with Task Domains

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/api/taskdomains.md

Provides an example of starting a workflow using the Java client, including specifying task-to-domain mappings. This allows for directing tasks to specific domains during workflow initiation.

```java
Map<String, Object> input = new HashMap<>();
input.put("wf_input1", "one");

Map<String, String> taskToDomain = new HashMap<>();
taskToDomain.put("T2", "mydomain");

// Other options ...
// taskToDomain.put("*", "mydomain, NO_DOMAIN")
// taskToDomain.put("T2", "mydomain, fallbackDomain1, fallbackDomain2")

StartWorkflowRequest swr = new StartWorkflowRequest();
swr.withName("myWorkflow")
	.withCorrelationId("corr1")
	.withVersion(1)
	.withInput(input)
	.withTaskToDomain(taskToDomain);

wfclient.startWorkflow(swr);
```

--------------------------------

### SDK Integration Examples

Source: https://github.com/conductor-oss/conductor/blob/main/README.md

Links to various SDKs available for interacting with the Conductor API and building custom clients. These SDKs support different programming languages.

```md
* [**Java SDK:**](https://github.com/conductor-oss/java-sdk)
* [**Python SDK:**](https://github.com/conductor-oss/python-sdk)
* [**Javascript SDK:**](https://github.com/conductor-oss/javascript-sdk)
* [**Go SDK:**](https://github.com/conductor-oss/go-sdk)
* [**C# SDK:**](https://github.com/conductor-oss/csharp-sdk)
```

--------------------------------

### Starting Standard Workflow Execution Conductor SDK Java

Source: https://github.com/conductor-oss/conductor/blob/main/java-sdk/workflow_sdk.md

Starts the execution of a workflow definition that has been previously registered on the server. It returns a `CompletableFuture` representing the asynchronous execution. The example shows how to wait for the execution to complete and retrieve details like the workflow ID and status.

```java
//Returns a completable future
CompletableFuture<Workflow> execution = conductorWorkflow.execute(input);

//Wait for the workflow to complete -- useful if workflow completes within a reasonable amount of time
Workflow workflowRun = execution.get();

//Get the workflowId
String workflowId = workflowRun.getWorkflowId();

//Get the status of workflow execution
WorkflowStatus status = workflowRun.getStatus();
```

--------------------------------

### Building Conductor UI for Production (Shell)

Source: https://github.com/conductor-oss/conductor/blob/main/ui/README.md

Compiles and bundles the React application assets for production deployment. The static files are generated and placed into the `/build` directory, ready to be served by a web server.

```Shell
yarn build
```

--------------------------------

### Conductor MongoDB Persistence

Source: https://github.com/conductor-oss/conductor/blob/main/docs/resources/related.md

Configuration and examples for using MongoDB as the persistence unit for Conductor. Includes a Docker Compose setup with a MongoDB container.

```Java
https://github.com/maheshyaddanapudi/conductor/tree/mongo_persistence
```

--------------------------------

### Run Conductor Server with Gradle

Source: https://github.com/conductor-oss/conductor/blob/main/docs/devguide/running/source.md

Builds and runs the Conductor server using Gradle. The command navigates to the server directory and executes the Gradle wrapper script.

```shell
cd conductor/server
server $ ../gradlew bootRun
```

--------------------------------

### Starting Dynamic Workflow Execution Conductor SDK Java

Source: https://github.com/conductor-oss/conductor/blob/main/java-sdk/workflow_sdk.md

Starts the execution of a workflow by providing the definition directly, without requiring prior registration on the server. This is suitable for scenarios where workflow definitions are generated dynamically per execution. The example uses a `ConductorWorkflow` instance built via the SDK and executes it dynamically.

```java
//1. Use WorkflowBuilder to create ConductorWorkflow.
//2. Execute using the definition created by SDK.
CompletableFuture<Workflow> execution = conductorWorkflow.executeDynamic(input);
```

--------------------------------

### Contributing Guidelines

Source: https://github.com/conductor-oss/conductor/blob/main/README.md

Information on how to contribute to the Conductor project, including reporting issues, contributing code, and improving documentation. It also points to beginner-friendly tasks.

```md
- Report Issues: Open an [issue on GitHub](https://github.com/conductor-oss/conductor/issues).
- Contribute code: Check out our [Contribution Guide](CONTRIBUTING.md), and explore our [Good first issues](https://github.com/conductor-oss/conductor/labels/good%20first%20issue).
- Contribute to our Docs: Contribute edits or updates to keep our [documentation](https://github.com/conductor-oss/conductor/tree/main/docs) in great shape for the community.
- Build a Conductor SDK: Need an [SDK](https://github.com/conductor-sdk) not available for Conductor today? Build your own using the [Swagger API](http://localhost:8080) included with your local deployment.
```

--------------------------------

### Conductor Oracle Persistence

Source: https://github.com/conductor-oss/conductor/blob/main/docs/resources/related.md

Configuration and examples for using Oracle Database as the persistence unit for Conductor (tested with versions > 12.2, including 19C). Includes a Docker Compose setup with an Oracle container.

```Java
https://github.com/maheshyaddanadi/conductor/tree/oracle_persistence
```

--------------------------------

### Clone Conductor Repository

Source: https://github.com/conductor-oss/conductor/blob/main/docs/devguide/running/source.md

Clones the Conductor project from its GitHub repository. This is the first step in building Conductor from source.

```shell
git clone https://github.com/conductor-oss/conductor.git
```

--------------------------------

### REST API: Start Workflow with Task Domains

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/api/taskdomains.md

Shows how to initiate a workflow via the REST API, including a `taskToDomain` mapping to control task routing. This example demonstrates setting a global domain and specific task overrides.

```rest
POST {{ api_prefix }}/workflow

{
  "name": "myWorkflow",
  "version": 1,
  "correlatonId": "corr1"
  "input": {
	"wf_input1": "one"
  },
  "taskToDomain": {
	"*": "mydomain",
	"some_task_x":"NO_DOMAIN",
    "some_task_y": "someDomain, NO_DOMAIN"
  }
}
```

--------------------------------

### Build Conductor UI Docker Image

Source: https://github.com/conductor-oss/conductor/blob/main/docker/ui/README.md

Builds the Docker image for the Conductor UI. This command should be run from the project root directory.

```bash
docker build -f docker/ui/Dockerfile -t conductor:ui .
```

--------------------------------

### Set up Logging

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/clientsdks/go-sdk.md

Configures the logrus logger for the Go SDK. This includes setting the formatter, output, and log level for debugging and operational insights.

```go
func init() {
	log.SetFormatter(&log.TextFormatter{})
	log.SetOutput(os.Stdout)
	log.SetLevel(log.DebugLevel)
}
```

--------------------------------

### Initializing Conductor Workflow Test Runner - Java

Source: https://github.com/conductor-oss/conductor/blob/main/conductor-clients/java/conductor-java-sdk/sdk/testing_framework.md

Initializes the local Conductor test server and workflow executor. It starts a local server instance at the specified port and version, then scans the provided package for task worker implementations. This setup is typically performed once before running test cases.

```java
//Setup method  code - should be called once per the test lifecycle
//e.g. @BeforeClass in JUnit

//Download the published conductor server version 3.5.2 
//Start the local server at port 8096
testRunner = new WorkflowTestRunner(8096, "3.5.2");

//Scan the packages for task workers
testRunner.init("com.netflix.conductor.testing.workflows");

//Get the executor instance used for  loading workflows 
executor = testRunner.getWorkflowExecutor();
```

--------------------------------

### Create Conductor Client Instance - Java

Source: https://github.com/conductor-oss/conductor/blob/main/conductor-clients/java/conductor-java-sdk/conductor-client/README.md

Creates an instance of the `ConductorClient` class, providing the URL of the Conductor API endpoint. This client instance is the entry point for interacting with the Conductor server. Requires the `conductor-client` dependency and a running Conductor server at the specified URL.

```Java
import com.netflix.conductor.client.http.ConductorClient;

// … other code
var client = new ConductorClient("http://localhost:8080/api");
```

--------------------------------

### Start Workflow Task Configuration

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/configuration/workflowdef/operators/start-workflow-task.md

Defines the configuration for starting a workflow. The `startWorkflow` parameter accepts a map containing details for the workflow to be initiated.

```APIDOC
inputParameters:
  startWorkflow: Map[String, Any]
    description: The value of this parameter is [Start Workflow Request](../../../api/startworkflow.md#start-workflow-request).

Output:
  workflowId: String
    description: The id of the started workflow
```

--------------------------------

### Run Conductor UI Development Server

Source: https://github.com/conductor-oss/conductor/blob/main/docs/devguide/running/source.md

Starts the Conductor UI development server using Yarn. This command builds and serves the React application for local development.

```shell
ui $ yarn run start
```

--------------------------------

### Start Workflow API Endpoint

Source: https://github.com/conductor-oss/conductor/blob/main/docs/devguide/how-tos/Workflows/starting-workflows.md

The REST API endpoint for starting a workflow execution. It accepts the workflow name in the URL and workflow input parameters in the POST request body.

```http
POST {{ api_prefix }}/workflow/{name}
```

--------------------------------

### Run Conductor Server with Specific Configuration

Source: https://github.com/conductor-oss/conductor/blob/main/docs/devguide/running/source.md

Runs the Conductor server using Gradle, specifying a custom configuration file via the `CONFIG_PROP` environment variable. This allows for customized server behavior.

```shell
# Ensure all other services have been started before running the server
server $ CONFIG_PROP=config.properties ../gradlew bootRun
```

--------------------------------

### Workflow Definition Example

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/advanced/isolationgroups.md

An example of a Conductor workflow definition that includes an HTTP task.

```json
{
  "name": "encode_and_deploy",
  "description": "Encodes a file and deploys to CDN",
  "version": 1,
  "tasks": [
    {
      "name": "encode",
      "taskReferenceName": "encode",
      "type": "HTTP", 
      "inputParameters": {
        "http_request": {
          "uri": "http://localhost:9200/conductor/_search?size=10",
          "method": "GET"
        }
      }
    }
  ],
  "outputParameters": {
    "cdn_url": "${d1.output.location}"
  },
  "failureWorkflow": "cleanup_encode_resources",
  "restartable": true,
  "workflowStatusListenerEnabled": true,
  "schemaVersion": 2
}
```

--------------------------------

### Implement and Run Conductor Worker - Java

Source: https://github.com/conductor-oss/conductor/blob/main/conductor-clients/java/conductor-java-sdk/conductor-client/README.md

Shows how to create a class implementing the `Worker` interface to handle tasks named "hello_task". The `execute` method defines the task logic. The `main` method demonstrates setting up and starting `TaskRunnerConfigurer` with the worker implementation to poll Conductor for tasks. Requires `conductor-client` dependency and a running Conductor server.

```Java
public class HelloWorker implements Worker {

    @Override
    public TaskResult execute(Task task) {
        var taskResult = new TaskResult(task);
        taskResult.setStatus(TaskResult.Status.COMPLETED);
        taskResult.getOutputData().put("message", "Hello World!");
        return taskResult;
    }

    @Override
    public String getTaskDefName() {
        return "hello_task";
    }

    public static void main(String[] args) {
        var client = new ConductorClient("http://localhost:8080/api");
        var taskClient = new TaskClient(client);
        var runnerConfigurer = new TaskRunnerConfigurer
                .Builder(taskClient, List.of(new HelloWorker()))
                .withThreadCount(10)
                .build();
        runnerConfigurer.init();
    }
}
```

--------------------------------

### Build Conductor UI for Production

Source: https://github.com/conductor-oss/conductor/blob/main/docs/devguide/running/source.md

Builds the Conductor UI project for production deployment. This command generates optimized static assets that can be hosted on a web server.

```shell
yarn build
```

--------------------------------

### Configure Protobuf Plugin for Apple Silicon

Source: https://github.com/conductor-oss/conductor/blob/main/docs/devguide/running/source.md

Modifies the `build.gradle` file for the gRPC plugin to include 'osx-x86_64' for compatibility with Apple silicon Macs. This is a specific configuration step for Mac users.

```gradle
protobuf {
    plugins {
        grpc {
            artifact = "io.grpc:protoc-gen-grpc-java:${revGrpc}:osx-x86_64"
        }
    }
...
}
```

--------------------------------

### Start Conductor with Docker Compose (Default)

Source: https://github.com/conductor-oss/conductor/blob/main/docs/devguide/running/docker.md

Starts Conductor using the default Docker Compose configuration, which includes Redis and Elasticsearch.

```shell
cd conductor
conductor $ docker compose -f docker/docker-compose.yaml up
```

--------------------------------

### Conductor SDKs Overview

Source: https://github.com/conductor-oss/conductor/blob/main/polyglot-clients/README.md

This section provides an overview of the available SDKs for Conductor. It links to the central conductor-sdk repository and lists supported languages.

```Markdown
# SDKs for other languages

Language specific client SDKs are maintained at a dedicated [conductor-sdk](https://github.com/conductor-sdk) repository.


Check the repository for the latest list, but there are SDK clients for:

## SDK List
* [Clojure](https://github.com/conductor-sdk/conductor-clojure)
* [C#](https://github.com/conductor-sdk/conductor-csharp)
* [Go](https://github.com/conductor-sdk/conductor-go)
* [Python](https://github.com/conductor-sdk/conductor-python)


### In progress (PRs encouraged!)
* [JavaScript](https://github.com/conductor-sdk/conductor-javascript)
```

--------------------------------

### JSON_JQ_TRANSFORM Task Output Example

Source: https://github.com/conductor-oss/conductor/blob/main/docs/documentation/configuration/workflowdef/systemtasks/json-jq-transform-task.md

Example output from a JSON_JQ_TRANSFORM task, showing the 'result' and 'resultList' attributes containing the transformed JSON.

```json
{
  "result": {
    "key3": [
      "a",
      "b",
      "c",
      "d"
    ]
  },
  "resultList": [
    {
      "key3": [
        "a",
        "b",
        "c",
        "d"
      ]
    }
  ]
}
```