conductor_ruby 0.1.0

data/lib/conductor/client/workflow_client.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative '../configuration'
+require_relative '../http/api_client'
+require_relative '../http/api/workflow_resource_api'
+
+module Conductor
+  module Client
+    # WorkflowClient - High-level client for workflow operations
+    class WorkflowClient
+      attr_reader :workflow_api
+
+      # Initialize WorkflowClient
+      # @param [Configuration] configuration Optional configuration
+      def initialize(configuration = nil)
+        @configuration = configuration || Configuration.new
+        api_client = Http::ApiClient.new(configuration: @configuration)
+        @workflow_api = Http::Api::WorkflowResourceApi.new(api_client)
+      end
+
+      # Start a new workflow
+      # @param [StartWorkflowRequest] request Start workflow request
+      # @return [String] Workflow ID
+      def start_workflow(request)
+        @workflow_api.start_workflow(request)
+      end
+
+      # Start a workflow with name and input, or with a StartWorkflowRequest
+      # @param [String, StartWorkflowRequest] name_or_request Workflow name or StartWorkflowRequest
+      # @param [Hash] input Workflow input data (default: {}, ignored if request object passed)
+      # @param [Integer] version Workflow version (optional, ignored if request object passed)
+      # @param [String] correlation_id Correlation ID (optional, ignored if request object passed)
+      # @return [String] Workflow ID
+      def start(name_or_request, input: {}, version: nil, correlation_id: nil)
+        # Handle both StartWorkflowRequest objects and simple name/input arguments
+        if name_or_request.is_a?(Http::Models::StartWorkflowRequest)
+          start_workflow(name_or_request)
+        else
+          request = Http::Models::StartWorkflowRequest.new(
+            name: name_or_request,
+            input: input,
+            version: version,
+            correlation_id: correlation_id
+          )
+          start_workflow(request)
+        end
+      end
+
+      # Get workflow execution status
+      # @param [String] workflow_id Workflow ID
+      # @param [Boolean] include_tasks Include task details (default: true)
+      # @return [Workflow] Workflow object
+      def get_workflow(workflow_id, include_tasks: true)
+        @workflow_api.get_execution_status(workflow_id, include_tasks: include_tasks)
+      end
+
+      # Delete a workflow
+      # @param [String] workflow_id Workflow ID
+      # @param [Boolean] archive_workflow Archive workflow before deleting (default: true)
+      # @return [void]
+      def delete_workflow(workflow_id, archive_workflow: true)
+        @workflow_api.delete(workflow_id, archive_workflow: archive_workflow)
+      end
+
+      # Terminate a running workflow
+      # @param [String] workflow_id Workflow ID
+      # @param [String] reason Termination reason (optional)
+      # @return [void]
+      def terminate_workflow(workflow_id, reason: nil)
+        @workflow_api.terminate(workflow_id, reason: reason)
+      end
+
+      # Pause a workflow
+      # @param [String] workflow_id Workflow ID
+      # @return [void]
+      def pause_workflow(workflow_id)
+        @workflow_api.pause_workflow(workflow_id)
+      end
+
+      # Resume a paused workflow
+      # @param [String] workflow_id Workflow ID
+      # @return [void]
+      def resume_workflow(workflow_id)
+        @workflow_api.resume_workflow(workflow_id)
+      end
+
+      # Restart a completed workflow
+      # @param [String] workflow_id Workflow ID
+      # @param [Boolean] use_latest_def Use latest workflow definition (default: false)
+      # @return [void]
+      def restart_workflow(workflow_id, use_latest_def: false)
+        @workflow_api.restart(workflow_id, use_latest_def: use_latest_def)
+      end
+
+      # Retry a failed workflow
+      # @param [String] workflow_id Workflow ID
+      # @param [Boolean] resume_subworkflow_tasks Resume subworkflow tasks (default: false)
+      # @return [void]
+      def retry_workflow(workflow_id, resume_subworkflow_tasks: false)
+        @workflow_api.retry(workflow_id, resume_subworkflow_tasks: resume_subworkflow_tasks)
+      end
+
+      # Rerun a workflow from a specific task
+      # @param [String] workflow_id Workflow ID
+      # @param [RerunWorkflowRequest] rerun_request Rerun request
+      # @return [String] New workflow ID
+      def rerun_workflow(workflow_id, rerun_request)
+        @workflow_api.rerun(workflow_id, rerun_request)
+      end
+
+      # Get workflows by correlation ID
+      # @param [String] name Workflow name
+      # @param [String] correlation_id Correlation ID
+      # @param [Boolean] include_closed Include closed workflows (default: false)
+      # @param [Boolean] include_tasks Include task details (default: false)
+      # @return [Array<Workflow>] List of workflows
+      def get_by_correlation_id(name, correlation_id, include_closed: false, include_tasks: false)
+        @workflow_api.get_workflows(name, correlation_id, include_closed: include_closed, include_tasks: include_tasks)
+      end
+
+      # Get running workflows by name
+      # @param [String] name Workflow name
+      # @param [Integer] version Workflow version (optional)
+      # @param [Integer] start_time Start time in epoch millis (optional)
+      # @param [Integer] end_time End time in epoch millis (optional)
+      # @return [Array<String>] List of workflow IDs
+      def get_running_workflows(name, version: nil, start_time: nil, end_time: nil)
+        @workflow_api.get_running_workflow(name, version: version, start_time: start_time, end_time: end_time)
+      end
+
+      # Register a workflow definition
+      # @param [WorkflowDef] workflow_def Workflow definition to register
+      # @param [Boolean] overwrite Overwrite existing definition (default: false)
+      # @return [void]
+      def register_workflow(workflow_def, overwrite: false)
+        @workflow_api.register_workflow(workflow_def, overwrite: overwrite)
+      end
+
+      # Get a workflow definition
+      # @param [String] name Workflow name
+      # @param [Integer] version Workflow version (optional)
+      # @return [WorkflowDef] Workflow definition
+      def get_workflow_def(name, version: nil)
+        @workflow_api.get_workflow_def(name, version: version)
+      end
+
+      # Delete a workflow definition
+      # @param [String] name Workflow name
+      # @param [Integer] version Workflow version
+      # @return [void]
+      def unregister_workflow(name, version:)
+        @workflow_api.unregister_workflow(name, version: version)
+      end
+
+      # Execute a workflow synchronously and wait for completion
+      # @param [StartWorkflowRequest] request Start workflow request
+      # @param [String] request_id Unique request ID (optional, auto-generated)
+      # @param [String] wait_until_task_ref Wait until task ref (optional)
+      # @param [Integer] wait_for_seconds Max wait time (default: 30)
+      # @return [WorkflowRun] Workflow run result
+      def execute_workflow(request, request_id: nil, wait_until_task_ref: nil, wait_for_seconds: 30)
+        request_id ||= SecureRandom.uuid
+        @workflow_api.execute_workflow(
+          request,
+          name: request.name,
+          version: request.version || 1,
+          request_id: request_id,
+          wait_until_task_ref: wait_until_task_ref,
+          wait_for_seconds: wait_for_seconds
+        )
+      end
+
+      # Search for workflows
+      # @param [Integer] start Start index (default: 0)
+      # @param [Integer] size Page size (default: 100)
+      # @param [String] free_text Free text search (default: '*')
+      # @param [String] query Query string (optional)
+      # @return [SearchResult] Search results
+      def search(start: 0, size: 100, free_text: '*', query: nil)
+        @workflow_api.search(start: start, size: size, free_text: free_text, query: query)
+      end
+
+      # Get workflows by multiple correlation IDs (batch)
+      # @param [String] name Workflow name
+      # @param [Array<String>] correlation_ids Correlation IDs
+      # @param [Boolean] include_closed Include closed workflows (default: false)
+      # @param [Boolean] include_tasks Include task details (default: false)
+      # @return [Hash<String, Array<Workflow>>]
+      def get_by_correlation_ids(name, correlation_ids, include_closed: false, include_tasks: false)
+        @workflow_api.get_workflows_batch(name, correlation_ids, include_closed: include_closed,
+                                                                 include_tasks: include_tasks)
+      end
+
+      # Update workflow variables
+      # @param [String] workflow_id Workflow ID
+      # @param [Hash] variables Variables to update
+      # @return [Workflow]
+      def update_variables(workflow_id, variables)
+        @workflow_api.update_workflow_state(workflow_id, variables)
+      end
+
+      # Update workflow and task state
+      # @param [String] workflow_id Workflow ID
+      # @param [WorkflowStateUpdate] state_update State update request
+      # @param [String] wait_until_task_ref Wait until task ref (optional)
+      # @param [Integer] wait_for_seconds Wait time (default: 10)
+      # @return [WorkflowRun]
+      def update_state(workflow_id, state_update, wait_until_task_ref: nil, wait_for_seconds: 10)
+        @workflow_api.update_workflow_and_task_state(
+          workflow_id, state_update,
+          wait_until_task_ref: wait_until_task_ref,
+          wait_for_seconds: wait_for_seconds
+        )
+      end
+
+      # Test a workflow with mocked task outputs
+      # @param [WorkflowTestRequest] request Test request
+      # @return [Workflow]
+      def test_workflow(request)
+        @workflow_api.test_workflow(request)
+      end
+
+      # Skip a task in a running workflow
+      # @param [String] workflow_id Workflow ID
+      # @param [String] task_reference_name Task reference name
+      # @param [SkipTaskRequest] request Skip task request (optional)
+      # @return [void]
+      def skip_task_from_workflow(workflow_id, task_reference_name, request: nil)
+        @workflow_api.skip_task_from_workflow(workflow_id, task_reference_name, request: request)
+      end
+
+      # Remove (permanently delete) a workflow
+      # @param [String] workflow_id Workflow ID
+      # @param [Boolean] archive_workflow Archive before deleting (default: true)
+      # @return [void]
+      def remove_workflow(workflow_id, archive_workflow: true)
+        @workflow_api.delete(workflow_id, archive_workflow: archive_workflow)
+      end
+    end
+  end
+end

data/lib/conductor/configuration/authentication_settings.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Conductor
+  # Authentication settings for Conductor server
+  class AuthenticationSettings
+    attr_accessor :key_id, :key_secret
+
+    def initialize(key_id: nil, key_secret: nil)
+      @key_id = key_id || ENV.fetch('CONDUCTOR_AUTH_KEY', nil)
+      @key_secret = key_secret || ENV.fetch('CONDUCTOR_AUTH_SECRET', nil)
+    end
+
+    def configured?
+      !key_id.nil? && !key_secret.nil? && !key_id.empty? && !key_secret.empty?
+    end
+  end
+end

data/lib/conductor/configuration.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative 'configuration/authentication_settings'
+
+module Conductor
+  # Configuration for Conductor client
+  class Configuration
+    # Class-level auth token cache (shared across instances, like Python SDK)
+    @auth_token = nil
+    @token_update_time = 0
+
+    class << self
+      attr_accessor :auth_token, :token_update_time
+    end
+
+    attr_accessor :base_url, :server_api_url, :debug, :authentication_settings,
+                  :verify_ssl, :ssl_ca_cert, :cert_file, :key_file,
+                  :proxy, :auth_token_ttl_min
+
+    attr_reader :host, :ui_host
+
+    def initialize(base_url: nil, server_api_url: nil, debug: false,
+                   authentication_settings: nil, auth_key: nil, auth_secret: nil,
+                   auth_token_ttl_min: 45, verify_ssl: true)
+      @debug = debug
+      @verify_ssl = verify_ssl
+      @ssl_ca_cert = nil
+      @cert_file = nil
+      @key_file = nil
+      @proxy = nil
+      @auth_token_ttl_min = auth_token_ttl_min
+
+      # Resolve server URL
+      @host = resolve_host(server_api_url, base_url)
+      @ui_host = resolve_ui_host
+
+      # Resolve authentication
+      @authentication_settings = resolve_auth_settings(authentication_settings, auth_key, auth_secret)
+    end
+
+    def auth_token_ttl_msec
+      @auth_token_ttl_min * 60 * 1000
+    end
+
+    def auth_configured?
+      @authentication_settings&.configured? || false
+    end
+
+    def disable_auth!
+      @authentication_settings = nil
+    end
+
+    def update_token(token)
+      self.class.auth_token = token
+      self.class.token_update_time = (Time.now.to_f * 1000).to_i
+    end
+
+    def auth_token
+      self.class.auth_token
+    end
+
+    def token_update_time
+      self.class.token_update_time
+    end
+
+    # Alias for server URL (used in some places)
+    def server_url
+      @host
+    end
+
+    private
+
+    def resolve_host(server_api_url, base_url)
+      return server_api_url if server_api_url
+      return "#{base_url}/api" if base_url
+
+      # Fall back to environment variable or default
+      env_url = ENV.fetch('CONDUCTOR_SERVER_URL', nil)
+      return env_url if env_url
+
+      'http://localhost:8080/api'
+    end
+
+    def resolve_ui_host
+      env_ui_url = ENV.fetch('CONDUCTOR_UI_SERVER_URL', nil)
+      return env_ui_url if env_ui_url
+
+      # Derive UI host from API host
+      @host.sub(%r{/api$}, '')
+    end
+
+    def resolve_auth_settings(auth_settings, auth_key, auth_secret)
+      return auth_settings if auth_settings
+
+      # Try explicit parameters first
+      return AuthenticationSettings.new(key_id: auth_key, key_secret: auth_secret) if auth_key && auth_secret
+
+      # Try environment variables
+      settings = AuthenticationSettings.new
+      settings.configured? ? settings : nil
+    end
+  end
+end

data/lib/conductor/exceptions.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Conductor
+  # Base exception for all Conductor errors
+  class ConductorError < StandardError; end
+
+  # Configuration error (invalid settings, missing dependencies)
+  class ConfigurationError < ConductorError; end
+
+  # API-level exception (HTTP errors from server)
+  class ApiError < ConductorError
+    attr_reader :status, :code, :reason, :body, :headers
+
+    def initialize(message = nil, status: nil, code: nil, reason: nil, body: nil, headers: nil)
+      @status = status
+      @code = code || status
+      @reason = reason
+      @body = body
+      @headers = headers
+      super(message || build_message)
+    end
+
+    def not_found?
+      @code == 404
+    end
+
+    private
+
+    def build_message
+      msg = "(#{@status}) #{@reason}"
+      msg += "\nBody: #{@body}" if @body
+      msg
+    end
+  end
+
+  # Authorization error (401/403 with special token handling)
+  class AuthorizationError < ApiError
+    attr_reader :error_code
+
+    def initialize(message = nil, status: nil, body: nil, headers: nil)
+      @error_code = parse_error_code(body)
+      super(message, status: status, body: body, headers: headers)
+    end
+
+    def token_expired?
+      @error_code == 'EXPIRED_TOKEN'
+    end
+
+    def invalid_token?
+      @error_code == 'INVALID_TOKEN'
+    end
+
+    private
+
+    def parse_error_code(body)
+      return nil unless body
+
+      data = begin
+        JSON.parse(body)
+      rescue StandardError
+        nil
+      end
+      data&.dig('error') || ''
+    end
+
+    def build_message
+      msg = "Authorization error: #{@error_code} (status: #{@status})"
+      msg += "\nReason: #{@reason}" if @reason
+      msg += "\nBody: #{@body}" if @body
+      msg
+    end
+  end
+
+  # Non-retryable worker error (terminal failure)
+  class NonRetryableError < ConductorError; end
+
+  # Task in progress (not an error - for long-running tasks)
+  class TaskInProgress
+    attr_reader :callback_after_seconds, :output
+
+    def initialize(callback_after: 60, output: {})
+      @callback_after_seconds = callback_after
+      @output = output
+    end
+  end
+end

data/lib/conductor/http/api/application_resource_api.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative '../api_client'
+
+module Conductor
+  module Http
+    module Api
+      # ApplicationResourceApi - API for application management operations (Orkes)
+      class ApplicationResourceApi
+        attr_accessor :api_client
+
+        def initialize(api_client = nil)
+          @api_client = api_client || ApiClient.new
+        end
+
+        # Create an application
+        def create_application(body)
+          @api_client.call_api('/applications', 'POST', body: body, return_type: 'ConductorApplication',
+                                                        return_http_data_only: true)
+        end
+
+        # Get an application by ID
+        def get_application(id)
+          @api_client.call_api('/applications/{id}', 'GET', path_params: { id: id },
+                                                            return_type: 'ConductorApplication', return_http_data_only: true)
+        end
+
+        # List all applications
+        def list_applications
+          @api_client.call_api('/applications', 'GET', return_type: 'Array<ConductorApplication>',
+                                                       return_http_data_only: true)
+        end
+
+        # Update an application
+        def update_application(body, id)
+          @api_client.call_api('/applications/{id}', 'PUT', path_params: { id: id }, body: body,
+                                                            return_type: 'ConductorApplication', return_http_data_only: true)
+        end
+
+        # Delete an application
+        def delete_application(id)
+          @api_client.call_api('/applications/{id}', 'DELETE', path_params: { id: id }, return_http_data_only: true)
+        end
+
+        # Add a role to an application
+        def add_role_to_application_user(application_id, role)
+          @api_client.call_api('/applications/{applicationId}/roles/{role}', 'POST',
+                               path_params: { applicationId: application_id, role: role }, return_http_data_only: true)
+        end
+
+        # Remove a role from an application
+        def remove_role_from_application_user(application_id, role)
+          @api_client.call_api('/applications/{applicationId}/roles/{role}', 'DELETE',
+                               path_params: { applicationId: application_id, role: role }, return_http_data_only: true)
+        end
+
+        # Set tags for an application
+        def put_tags_for_application(tags, id)
+          @api_client.call_api('/applications/{id}/tags', 'PUT', path_params: { id: id }, body: tags,
+                                                                 return_http_data_only: true)
+        end
+
+        # Get tags for an application
+        def get_tags_for_application(id)
+          @api_client.call_api('/applications/{id}/tags', 'GET', path_params: { id: id },
+                                                                 return_type: 'Array<TagObject>', return_http_data_only: true)
+        end
+
+        # Delete tags for an application
+        def delete_tags_for_application(tags, id)
+          @api_client.call_api('/applications/{id}/tags', 'DELETE', path_params: { id: id }, body: tags,
+                                                                    return_http_data_only: true)
+        end
+
+        # Create an access key for an application
+        def create_access_key(id)
+          @api_client.call_api('/applications/{id}/accessKeys', 'POST', path_params: { id: id }, return_type: 'Object',
+                                                                        return_http_data_only: true)
+        end
+
+        # Get access keys for an application
+        def get_access_keys(id)
+          @api_client.call_api('/applications/{id}/accessKeys', 'GET', path_params: { id: id },
+                                                                       return_type: 'Array<Object>', return_http_data_only: true)
+        end
+
+        # Toggle access key status
+        def toggle_access_key_status(application_id, key_id)
+          @api_client.call_api('/applications/{applicationId}/accessKeys/{keyId}/status', 'POST',
+                               path_params: { applicationId: application_id, keyId: key_id }, return_type: 'Object', return_http_data_only: true)
+        end
+
+        # Delete an access key
+        def delete_access_key(application_id, key_id)
+          @api_client.call_api('/applications/{applicationId}/accessKeys/{keyId}', 'DELETE',
+                               path_params: { applicationId: application_id, keyId: key_id }, return_http_data_only: true)
+        end
+
+        # Get application by access key ID
+        def get_app_by_access_key_id(access_key_id)
+          @api_client.call_api('/applications/key/{accessKeyId}', 'GET', path_params: { accessKeyId: access_key_id },
+                                                                         return_type: 'Object', return_http_data_only: true)
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/api/authorization_resource_api.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../api_client'
+
+module Conductor
+  module Http
+    module Api
+      # AuthorizationResourceApi - API for permission management operations (Orkes)
+      class AuthorizationResourceApi
+        attr_accessor :api_client
+
+        def initialize(api_client = nil)
+          @api_client = api_client || ApiClient.new
+        end
+
+        # Grant permissions
+        # @param [AuthorizationRequest] body Authorization request
+        # @return [void]
+        def grant_permissions(body)
+          @api_client.call_api(
+            '/auth/authorization',
+            'POST',
+            body: body,
+            return_http_data_only: true
+          )
+        end
+
+        # Get permissions for a target
+        # @param [String] type Target type
+        # @param [String] id Target ID
+        # @return [Hash]
+        def get_permissions(type, id)
+          @api_client.call_api(
+            '/auth/authorization/{type}/{id}',
+            'GET',
+            path_params: { type: type, id: id },
+            return_type: 'Object',
+            return_http_data_only: true
+          )
+        end
+
+        # Remove permissions
+        # @param [AuthorizationRequest] body Authorization request
+        # @return [void]
+        def remove_permissions(body)
+          @api_client.call_api(
+            '/auth/authorization',
+            'DELETE',
+            body: body,
+            return_http_data_only: true
+          )
+        end
+      end
+    end
+  end
+end