conductor_ruby 0.1.0

data/examples/helloworld/greetings_worker.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Greetings Worker
+# ================
+# Simple worker that creates a greeting message.
+# For detailed explanation: https://github.com/conductor-oss/ruby-sdk
+
+require_relative '../../lib/conductor'
+
+# Worker that creates a greeting message
+class GreetingsWorker
+  include Conductor::Worker::WorkerModule
+
+  worker_task 'greet'
+
+  def execute(task)
+    name = get_input(task, 'name', 'World')
+    greeting = "Hello, #{name}!"
+
+    puts "[GreetingsWorker] Created greeting: #{greeting}"
+
+    { 'result' => greeting }
+  end
+end

data/examples/helloworld/helloworld.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Hello World Example
+# ===================
+#
+# The simplest complete example demonstrating:
+# 1. Define a workflow using the new Ruby-idiomatic DSL
+# 2. Register the workflow
+# 3. Start workers
+# 4. Execute the workflow
+# 5. Get the result
+#
+# Usage:
+#   cd examples/helloworld
+#   bundle exec ruby helloworld.rb
+#
+# Prerequisites:
+#   - Conductor server running (set CONDUCTOR_SERVER_URL env var)
+#   - For Orkes: Set CONDUCTOR_AUTH_KEY and CONDUCTOR_AUTH_SECRET
+
+require_relative 'greetings_worker'
+
+def create_greetings_workflow(executor)
+  # Define workflow using the new Ruby-idiomatic DSL
+  Conductor.workflow :greetings, version: 1, executor: executor do
+    # Create greet task that uses workflow input
+    # wf[:name] returns "${workflow.input.name}"
+    greet = simple :greet, name: wf[:name]
+
+    # Set output to be the result from greet task
+    # greet[:result] returns "${greet_ref.output.result}"
+    output result: greet[:result]
+  end
+end
+
+def main
+  # Configuration - reads from environment variables by default:
+  # CONDUCTOR_SERVER_URL: Conductor server URL (default: http://localhost:8080/api)
+  # CONDUCTOR_AUTH_KEY: API Authentication Key (optional for OSS)
+  # CONDUCTOR_AUTH_SECRET: API Auth Secret (optional for OSS)
+  config = Conductor::Configuration.new
+
+  puts '=' * 60
+  puts 'Conductor Ruby SDK - Hello World'
+  puts '=' * 60
+  puts
+  puts "Server: #{config.server_url}"
+  puts
+
+  # Create clients
+  clients = Conductor::Orkes::OrkesClients.new(config)
+  workflow_executor = clients.get_workflow_executor
+
+  # Create workflow with executor (required for register/execute)
+  workflow = create_greetings_workflow(workflow_executor)
+
+  # Register workflow (only needs to be done once)
+  puts 'Registering workflow...'
+  workflow.register(overwrite: true)
+  puts "Registered workflow: #{workflow.name} v#{workflow.version}"
+  puts
+
+  # Start workers
+  puts 'Starting workers...'
+  task_handler = Conductor::Worker::TaskRunner.new(config)
+  task_handler.register_worker(GreetingsWorker.new)
+  task_handler.start
+  puts 'Workers started!'
+  puts
+
+  # Execute workflow using the new DSL's execute method
+  puts 'Executing workflow with input: { name: "World" }'
+  workflow_run = workflow.execute(input: { 'name' => 'World' }, wait_for_seconds: 30)
+
+  puts
+  puts '-' * 60
+  puts "Workflow result: #{workflow_run.output['result']}"
+  puts '-' * 60
+  puts
+  puts "See the workflow execution at: #{config.ui_host}/execution/#{workflow_run.workflow_id}"
+
+  # Stop workers
+  task_handler.stop
+  puts
+  puts 'Done!'
+end
+
+if __FILE__ == $PROGRAM_NAME
+  begin
+    main
+  rescue Conductor::ApiError => e
+    puts "API Error: #{e.message}"
+    puts e.backtrace.first(5).join("\n")
+  rescue StandardError => e
+    puts "Error: #{e.message}"
+    puts e.backtrace.first(5).join("\n")
+  end
+end

data/examples/kitchensink.rb

@@ -0,0 +1,213 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Kitchen Sink Example
+# ====================
+#
+# Comprehensive example demonstrating all major workflow task types and patterns
+# using the new Ruby-idiomatic DSL.
+#
+# What it demonstrates:
+# ---------------------
+# - simple() - Custom worker tasks
+# - http() - External API calls
+# - javascript() - Inline JavaScript execution
+# - jq() - JSON transformation with JQ
+# - decide() - Conditional branching (switch)
+# - wait() - Pause workflow execution
+# - set() - Store workflow variables
+# - terminate() - End workflow with specific status
+# - sub_workflow() - Call another workflow
+# - parallel() - Concurrent task execution
+#
+# Usage:
+#   bundle exec ruby examples/kitchensink.rb
+
+require_relative '../lib/conductor'
+
+# ============================================================================
+# WORKER - Custom task implementation
+# ============================================================================
+
+class RouteWorker
+  include Conductor::Worker::WorkerModule
+
+  worker_task 'route'
+
+  def execute(task)
+    country = get_input(task, 'country', 'Unknown')
+    message = "routing the packages to #{country}"
+    puts "[RouteWorker] #{message}"
+    { 'result' => message }
+  end
+end
+
+def start_workers(config)
+  task_handler = Conductor::Worker::TaskRunner.new(config)
+  task_handler.register_worker(RouteWorker.new)
+  task_handler.start
+  task_handler
+end
+
+def create_sub_workflow(executor)
+  # Create a sub-workflow that will be called from the main workflow
+  Conductor.workflow :sub_ruby, version: 1, executor: executor do
+    # HTTP call using workflow input for URI
+    http :sub_call_api, url: wf[:uri]
+
+    # Wait for 2 seconds
+    wait 2
+  end
+end
+
+def create_kitchensink_workflow(executor)
+  # Main kitchen sink workflow using the new DSL
+  Conductor.workflow :kitchensink_ruby, version: 1, executor: executor do
+    # -------------------------------------------------------------------------
+    # 1. JavaScript Task - Execute inline JavaScript
+    # -------------------------------------------------------------------------
+    say_hello_js = <<~JS
+      function greetings() {
+          return {
+              "text": "hello " + $.name,
+              "url": "https://orkes-api-tester.orkesconductor.com/api"
+          }
+      }
+      greetings();
+    JS
+
+    js = javascript :hello_script, script: say_hello_js, name: wf[:name]
+
+    # -------------------------------------------------------------------------
+    # 2. Parallel Execution - HTTP call and sub-workflow run concurrently
+    # -------------------------------------------------------------------------
+    parallel do
+      # Branch 1: Call sub-workflow with URL from JS task
+      sub_workflow :call_sub_workflow, workflow: 'sub_ruby', version: 1, uri: js[:url]
+
+      # Branch 2: HTTP call followed by wait
+      http :call_remote_api, url: 'https://orkes-api-tester.orkesconductor.com/api'
+      wait 2
+    end
+
+    # -------------------------------------------------------------------------
+    # 3. JSON JQ Task - Transform JSON data
+    # -------------------------------------------------------------------------
+    jq :jq_process,
+       query: '{ key3: (.key1.value1 + .key2.value2) }',
+       key1: { 'value1' => %w[a b] },
+       key2: { 'value2' => %w[d e] }
+
+    # -------------------------------------------------------------------------
+    # 4. Set Variable Task - Store workflow variables
+    # -------------------------------------------------------------------------
+    set(
+      var1: 'value1',
+      var2: 42,
+      var3: %w[a b c]
+    )
+
+    # -------------------------------------------------------------------------
+    # 5. Switch Task - Conditional branching based on country
+    # -------------------------------------------------------------------------
+    decide wf[:country] do
+      on 'US' do
+        simple :route, country: wf[:country]
+      end
+
+      on 'CA' do
+        simple :route, country: wf[:country]
+      end
+
+      otherwise do
+        terminate :terminated, 'unsupported country'
+      end
+    end
+
+    # -------------------------------------------------------------------------
+    # Set workflow output
+    # -------------------------------------------------------------------------
+    output greetings: js[:output]
+  end
+end
+
+def main
+  # Configuration from environment variables
+  config = Conductor::Configuration.new
+
+  puts '=' * 70
+  puts 'Conductor Ruby SDK - Kitchen Sink Example (New DSL)'
+  puts '=' * 70
+  puts
+  puts "Server: #{config.server_url}"
+  puts
+
+  # Create clients
+  clients = Conductor::Orkes::OrkesClients.new(config)
+  workflow_executor = clients.get_workflow_executor
+
+  # Start workers
+  task_handler = start_workers(config)
+  puts 'Workers started...'
+  puts
+
+  # ============================================================================
+  # CREATE WORKFLOWS USING NEW DSL
+  # ============================================================================
+
+  sub_workflow = create_sub_workflow(workflow_executor)
+  main_workflow = create_kitchensink_workflow(workflow_executor)
+
+  # ============================================================================
+  # REGISTER SUB-WORKFLOW FIRST
+  # ============================================================================
+
+  puts 'Registering sub-workflow...'
+  sub_workflow.register(overwrite: true)
+  puts "Sub-workflow '#{sub_workflow.name}' registered!"
+  puts
+
+  # ============================================================================
+  # REGISTER AND EXECUTE MAIN WORKFLOW
+  # ============================================================================
+
+  puts 'Registering main workflow...'
+  main_workflow.register(overwrite: true)
+  puts "Main workflow '#{main_workflow.name}' registered!"
+  puts
+
+  puts 'Executing kitchen sink workflow...'
+  puts "Input: { name: 'Conductor Ruby', country: 'US' }"
+  puts
+
+  result = main_workflow.execute(
+    input: { 'name' => 'Conductor Ruby', 'country' => 'US' },
+    wait_for_seconds: 60
+  )
+
+  puts
+  puts 'Workflow completed!'
+  puts '-' * 70
+  puts "Workflow ID: #{result.workflow_id}"
+  puts "Status: #{result.status}"
+  puts "Output: #{result.output.inspect}"
+  puts
+  puts "See the execution at: #{config.ui_host}/execution/#{result.workflow_id}"
+
+  # Stop workers
+  task_handler.stop
+  puts
+  puts 'Workers stopped. Goodbye!'
+end
+
+if __FILE__ == $PROGRAM_NAME
+  begin
+    main
+  rescue Conductor::ApiError => e
+    puts "API Error: #{e.message}"
+    puts e.backtrace.first(5).join("\n")
+  rescue StandardError => e
+    puts "Error: #{e.message}"
+    puts e.backtrace.first(5).join("\n")
+  end
+end

data/examples/metadata_journey.rb

@@ -0,0 +1,189 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Metadata Management Journey
+#
+# Demonstrates all metadata operations: workflow definitions,
+# task definitions, and tagging.
+#
+# Usage:
+#   bundle exec ruby examples/metadata_journey.rb
+
+require_relative '../lib/conductor'
+
+class MetadataJourney
+  def initialize
+    @config = Conductor::Configuration.new
+    @clients = Conductor::Orkes::OrkesClients.new(@config)
+    @metadata = @clients.get_metadata_client
+
+    puts '=' * 70
+    puts 'Metadata Management Journey'
+    puts '=' * 70
+    puts "Server: #{@config.server_url}"
+    puts
+  end
+
+  def run
+    manage_task_definitions
+    manage_workflow_definitions
+    work_with_tags
+    cleanup
+  end
+
+  private
+
+  def manage_task_definitions
+    puts "\n--- Task Definitions ---"
+
+    # Create task definitions
+    tasks = [
+      {
+        'name' => 'ruby_process_order',
+        'description' => 'Process incoming orders',
+        'retryCount' => 3,
+        'retryLogic' => 'FIXED',
+        'retryDelaySeconds' => 10,
+        'timeoutSeconds' => 300,
+        'responseTimeoutSeconds' => 60
+      },
+      {
+        'name' => 'ruby_send_notification',
+        'description' => 'Send customer notifications',
+        'retryCount' => 2,
+        'timeoutSeconds' => 60
+      },
+      {
+        'name' => 'ruby_update_inventory',
+        'description' => 'Update inventory counts',
+        'retryCount' => 5,
+        'timeoutSeconds' => 120
+      }
+    ]
+
+    tasks.each do |task|
+      @metadata.register_task_def(task)
+      puts "Created task: #{task['name']}"
+    end
+
+    # Get a specific task
+    task = @metadata.get_task_def('ruby_process_order')
+    puts "\nRetrieved task: #{task['name'] || task.name}"
+
+    # Get all tasks
+    all_tasks = @metadata.get_all_task_defs
+    puts "Total tasks in system: #{all_tasks.length}"
+
+    @created_tasks = tasks.map { |t| t['name'] }
+  end
+
+  def manage_workflow_definitions
+    puts "\n--- Workflow Definitions ---"
+
+    # Create workflow definition
+    workflow_def = {
+      'name' => 'ruby_order_pipeline',
+      'description' => 'Complete order processing pipeline',
+      'version' => 1,
+      'schemaVersion' => 2,
+      'tasks' => [
+        {
+          'name' => 'ruby_process_order',
+          'taskReferenceName' => 'process_ref',
+          'type' => 'SIMPLE',
+          'inputParameters' => {
+            'orderId' => '${workflow.input.orderId}'
+          }
+        },
+        {
+          'name' => 'ruby_update_inventory',
+          'taskReferenceName' => 'inventory_ref',
+          'type' => 'SIMPLE',
+          'inputParameters' => {
+            'items' => '${process_ref.output.items}'
+          }
+        },
+        {
+          'name' => 'ruby_send_notification',
+          'taskReferenceName' => 'notify_ref',
+          'type' => 'SIMPLE',
+          'inputParameters' => {
+            'customerId' => '${workflow.input.customerId}',
+            'status' => '${inventory_ref.output.status}'
+          }
+        }
+      ],
+      'outputParameters' => {
+        'orderStatus' => '${notify_ref.output.status}'
+      },
+      'timeoutSeconds' => 600
+    }
+
+    @metadata.register_workflow_def(workflow_def, overwrite: true)
+    puts "Created workflow: #{workflow_def['name']}"
+
+    # Get the workflow
+    wf = @metadata.get_workflow_def('ruby_order_pipeline')
+    puts "Retrieved workflow: #{wf['name'] || wf.name}"
+
+    # Get all workflows
+    all_workflows = @metadata.get_all_workflow_defs
+    puts "Total workflows in system: #{all_workflows.length}"
+
+    @created_workflow = workflow_def['name']
+  end
+
+  def work_with_tags
+    puts "\n--- Working with Tags ---"
+
+    # Tag a workflow
+    tags = [
+      { 'key' => 'team', 'value' => 'orders' },
+      { 'key' => 'environment', 'value' => 'development' }
+    ]
+
+    begin
+      @metadata.add_workflow_tag('ruby_order_pipeline', tags.first)
+      puts "Added tag to workflow: #{tags.first['key']}=#{tags.first['value']}"
+
+      # Get workflow tags
+      wf_tags = @metadata.get_workflow_tags('ruby_order_pipeline')
+      puts "Workflow tags: #{wf_tags.length}"
+    rescue StandardError => e
+      puts "Tag operations: #{e.message}"
+    end
+  end
+
+  def cleanup
+    puts "\n--- Cleanup ---"
+
+    # Delete workflow
+    begin
+      @metadata.unregister_workflow_def(@created_workflow, 1)
+      puts "Deleted workflow: #{@created_workflow}"
+    rescue StandardError => e
+      puts "Could not delete workflow: #{e.message}"
+    end
+
+    # Delete tasks
+    @created_tasks&.each do |name|
+      @metadata.unregister_task_def(name)
+      puts "Deleted task: #{name}"
+    rescue StandardError => e
+      puts "Could not delete #{name}: #{e.message}"
+    end
+
+    puts "\nMetadata journey complete!"
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  begin
+    MetadataJourney.new.run
+  rescue Conductor::ApiError => e
+    puts "API Error: #{e.message}"
+  rescue StandardError => e
+    puts "Error: #{e.message}"
+    puts e.backtrace.first(3).join("\n")
+  end
+end