conductor_ruby 0.1.0

data/lib/conductor/http/models/workflow_test_request.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Request to test a workflow with mocked task outputs
+      class WorkflowTestRequest < BaseModel
+        SWAGGER_TYPES = {
+          workflow_def: 'WorkflowDef',
+          name: 'String',
+          version: 'Integer',
+          input: 'Hash<String, Object>',
+          correlation_id: 'String',
+          task_ref_to_mock_output: 'Hash<String, Array<WorkflowTestTaskResult>>',
+          external_input_payload_storage_path: 'String',
+          sub_workflow_test_request: 'Hash<String, WorkflowTestRequest>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          workflow_def: :workflowDef,
+          name: :name,
+          version: :version,
+          input: :input,
+          correlation_id: :correlationId,
+          task_ref_to_mock_output: :taskRefToMockOutput,
+          external_input_payload_storage_path: :externalInputPayloadStoragePath,
+          sub_workflow_test_request: :subWorkflowTestRequest
+        }.freeze
+
+        attr_accessor :workflow_def, :name, :version, :input, :correlation_id,
+                      :task_ref_to_mock_output, :external_input_payload_storage_path,
+                      :sub_workflow_test_request
+
+        def initialize(params = {})
+          @workflow_def = params[:workflow_def]
+          @name = params[:name]
+          @version = params[:version]
+          @input = params[:input] || {}
+          @correlation_id = params[:correlation_id]
+          @task_ref_to_mock_output = params[:task_ref_to_mock_output] || {}
+          @external_input_payload_storage_path = params[:external_input_payload_storage_path]
+          @sub_workflow_test_request = params[:sub_workflow_test_request] || {}
+        end
+      end
+
+      # Mock task result for workflow testing
+      class WorkflowTestTaskResult < BaseModel
+        SWAGGER_TYPES = {
+          status: 'String',
+          output: 'Hash<String, Object>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          status: :status,
+          output: :output
+        }.freeze
+
+        attr_accessor :status, :output
+
+        def initialize(params = {})
+          @status = params[:status] || 'COMPLETED'
+          @output = params[:output] || {}
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/rest_client.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/net_http_persistent'
+require 'faraday/retry'
+require 'json'
+require 'logger'
+require 'uri'
+
+module Conductor
+  module Http
+    # Faraday-based REST client with HTTP/2 support
+    class RestClient
+      attr_reader :connection
+
+      def initialize(configuration = nil, logger: nil)
+        @configuration = configuration
+        @logger = logger || Logger.new(File::NULL)
+        @connection = build_connection
+      end
+
+      # Main request method
+      def request(method, url, query: nil, headers: nil, body: nil, metric_uri: nil)
+        method = method.to_s.upcase
+        raise ArgumentError, "Invalid HTTP method: #{method}" unless valid_method?(method)
+
+        headers ||= {}
+        headers['Content-Type'] ||= 'application/json' if %w[POST PUT PATCH DELETE OPTIONS].include?(method)
+
+        timing = http_metrics_enabled?
+        start_time = Time.now if timing
+        status_code = '0'
+
+        begin
+          response = @connection.run_request(method.downcase.to_sym, url, nil, headers) do |req|
+            req.params = query if query
+            req.body = serialize_body(body, headers['Content-Type']) if body
+          end
+          status_code = response.status.to_s
+
+          result = handle_response(response)
+          emit_http_event(method, url, status_code, start_time, metric_uri: metric_uri) if timing
+          result
+        rescue Faraday::TimeoutError => e
+          emit_http_event(method, url, '0', start_time, metric_uri: metric_uri) if timing
+          raise ApiError.new("Request timeout: #{e.message}", status: 0, reason: 'Timeout')
+        rescue Faraday::ConnectionFailed => e
+          emit_http_event(method, url, '0', start_time, metric_uri: metric_uri) if timing
+          raise ApiError.new("Connection error: #{e.message}", status: 0, reason: 'ConnectionFailed')
+        rescue ApiError, AuthorizationError
+          emit_http_event(method, url, status_code, start_time, metric_uri: metric_uri) if timing
+          raise
+        end
+      end
+
+      # Convenience methods
+      def get(url, query: nil, headers: nil)
+        request('GET', url, query: query, headers: headers)
+      end
+
+      def post(url, body: nil, query: nil, headers: nil)
+        request('POST', url, query: query, headers: headers, body: body)
+      end
+
+      def put(url, body: nil, query: nil, headers: nil)
+        request('PUT', url, query: query, headers: headers, body: body)
+      end
+
+      def patch(url, body: nil, query: nil, headers: nil)
+        request('PATCH', url, query: query, headers: headers, body: body)
+      end
+
+      def delete(url, body: nil, query: nil, headers: nil)
+        request('DELETE', url, query: query, headers: headers, body: body)
+      end
+
+      def head(url, query: nil, headers: nil)
+        request('HEAD', url, query: query, headers: headers)
+      end
+
+      def options(url, body: nil, query: nil, headers: nil)
+        request('OPTIONS', url, query: query, headers: headers, body: body)
+      end
+
+      def close
+        @connection&.close
+      end
+
+      private
+
+      def http_metrics_enabled?
+        defined?(Conductor::Worker::Events::GlobalDispatcher) &&
+          Conductor::Worker::Events::GlobalDispatcher.http_metrics_enabled?
+      end
+
+      def emit_http_event(method, url, status, start_time, metric_uri: nil)
+        duration_ms = (Time.now - start_time) * 1000
+        uri_path = metric_uri || URI.parse(url).request_uri
+        event = Conductor::Worker::Events::HttpApiRequest.new(
+          method: method, uri: uri_path, status: status, duration_ms: duration_ms
+        )
+        Conductor::Worker::Events::GlobalDispatcher.publish(event)
+      rescue StandardError => e
+        @logger.debug { "Telemetry error (non-fatal): #{e.class}: #{e.message}" }
+      end
+
+      def build_connection
+        Faraday.new do |conn|
+          # HTTP/2 adapter with persistent connections
+          conn.adapter :net_http_persistent do |http|
+            http.idle_timeout = 30
+          end
+
+          # Retry middleware (3 retries with exponential backoff)
+          conn.request :retry,
+                       max: 3,
+                       interval: 0.5,
+                       backoff_factor: 2,
+                       retry_statuses: [408, 429, 500, 502, 503, 504],
+                       methods: %i[get post put patch delete]
+
+          # Connection settings
+          conn.options.timeout = 120      # 120s total timeout
+          conn.options.open_timeout = 10  # 10s connection timeout
+
+          # SSL settings from configuration
+          if @configuration
+            conn.ssl.verify = @configuration.verify_ssl
+            conn.ssl.ca_file = @configuration.ssl_ca_cert if @configuration.ssl_ca_cert
+            conn.ssl.client_cert = @configuration.cert_file if @configuration.cert_file
+            conn.ssl.client_key = @configuration.key_file if @configuration.key_file
+          end
+
+          # Proxy settings
+          conn.proxy = @configuration.proxy if @configuration&.proxy
+        end
+      end
+
+      def valid_method?(method)
+        %w[GET HEAD DELETE POST PUT PATCH OPTIONS].include?(method)
+      end
+
+      def serialize_body(body, content_type)
+        return body if body.is_a?(String)
+
+        if content_type&.include?('json')
+          body.is_a?(Hash) || body.is_a?(Array) ? JSON.generate(body) : body.to_s
+        else
+          body
+        end
+      end
+
+      def handle_response(response)
+        # Check for auth errors first (401/403)
+        if [401, 403].include?(response.status)
+          raise AuthorizationError.new(
+            "Authorization failed: #{response.status}",
+            status: response.status,
+            body: response.body,
+            headers: response.headers.to_h
+          )
+        end
+
+        # Check for other non-2xx responses
+        unless (200..299).cover?(response.status)
+          error_message = parse_error_message(response)
+          raise ApiError.new(
+            error_message,
+            status: response.status,
+            code: response.status,
+            reason: response.reason_phrase,
+            body: response.body,
+            headers: response.headers.to_h
+          )
+        end
+
+        # Return successful response
+        RestResponse.new(response)
+      end
+
+      def parse_error_message(response)
+        # Try to parse JSON error message
+        data = begin
+          JSON.parse(response.body)
+        rescue StandardError
+          nil
+        end
+        message = data&.dig('message') || response.reason_phrase || "HTTP #{response.status}"
+        "(#{response.status}) #{message}"
+      end
+    end
+
+    # Wrapper for Faraday response
+    class RestResponse
+      attr_reader :status, :reason, :body, :headers
+
+      def initialize(faraday_response)
+        @status = faraday_response.status
+        @reason = faraday_response.reason_phrase
+        @body = faraday_response.body
+        @headers = faraday_response.headers.to_h
+      end
+
+      def json
+        @json ||= JSON.parse(@body) if @body && !@body.empty?
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/conductor/orkes/models/access_key.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Orkes
+    module Models
+      # AccessKeyStatus constants
+      module AccessKeyStatus
+        ACTIVE = 'ACTIVE'
+        INACTIVE = 'INACTIVE'
+      end
+
+      # AccessKey model - represents an application access key
+      class AccessKey < Conductor::Http::Models::BaseModel
+        SWAGGER_TYPES = {
+          id: 'String',
+          status: 'String',
+          created_at: 'Integer'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          id: :id,
+          status: :status,
+          created_at: :createdAt
+        }.freeze
+
+        attr_accessor :id, :status, :created_at
+
+        def initialize(params = {})
+          @id = params[:id]
+          @status = params[:status] || AccessKeyStatus::ACTIVE
+          @created_at = params[:created_at]
+        end
+      end
+
+      # CreatedAccessKey model - returned when creating a new access key
+      class CreatedAccessKey < Conductor::Http::Models::BaseModel
+        SWAGGER_TYPES = {
+          id: 'String',
+          secret: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          id: :id,
+          secret: :secret
+        }.freeze
+
+        attr_accessor :id, :secret
+
+        def initialize(params = {})
+          @id = params[:id]
+          @secret = params[:secret]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/orkes/models/granted_permission.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Orkes
+    module Models
+      # GrantedPermission model - represents a permission granted on a target
+      class GrantedPermission < Conductor::Http::Models::BaseModel
+        SWAGGER_TYPES = {
+          target: 'TargetRef',
+          access: 'Array<String>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          target: :target,
+          access: :access
+        }.freeze
+
+        attr_accessor :target, :access
+
+        def initialize(params = {})
+          @target = params[:target]
+          @access = params[:access]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/orkes/models/metadata_tag.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Orkes
+    module Models
+      # MetadataTag - a tag with type METADATA
+      # Convenience subclass of TagObject that sets type to METADATA
+      class MetadataTag < Conductor::Http::Models::TagObject
+        def initialize(key:, value:)
+          super(key: key, type: Conductor::Http::Models::TagType::METADATA, value: value)
+        end
+      end
+    end
+  end
+end

data/lib/conductor/orkes/models/rate_limit_tag.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Orkes
+    module Models
+      # RateLimitTag - a tag with type RATE_LIMIT
+      # Convenience subclass of TagObject that sets type to RATE_LIMIT
+      class RateLimitTag < Conductor::Http::Models::TagObject
+        def initialize(key:, value:)
+          super(key: key, type: Conductor::Http::Models::TagType::RATE_LIMIT, value: value)
+        end
+      end
+    end
+  end
+end

data/lib/conductor/orkes/orkes_clients.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Orkes
+    # OrkesClients - Factory class that creates all high-level clients from a single configuration
+    # This is the primary entry point for Orkes Conductor users.
+    #
+    # Usage:
+    #   config = Conductor::Configuration.new
+    #   config.server_url = 'https://developer.orkescloud.com/api'
+    #   config.authentication_settings = Conductor::Configuration::AuthenticationSettings.new(
+    #     key_id: 'your_key', key_secret: 'your_secret'
+    #   )
+    #   clients = Conductor::Orkes::OrkesClients.new(config)
+    #
+    #   workflow_client = clients.get_workflow_client
+    #   task_client = clients.get_task_client
+    #   secret_client = clients.get_secret_client
+    #
+    class OrkesClients
+      attr_reader :configuration, :api_client
+
+      def initialize(configuration = nil)
+        @configuration = configuration || Configuration.new
+        @api_client = Http::ApiClient.new(configuration: @configuration)
+      end
+
+      def get_workflow_client
+        Client::WorkflowClient.new(@configuration)
+      end
+
+      def get_task_client
+        Client::TaskClient.new(@configuration)
+      end
+
+      def get_metadata_client
+        Client::MetadataClient.new(@configuration)
+      end
+
+      def get_scheduler_client
+        Client::SchedulerClient.new(@configuration)
+      end
+
+      def get_authorization_client
+        Client::AuthorizationClient.new(@api_client)
+      end
+
+      def get_secret_client
+        Client::SecretClient.new(@api_client)
+      end
+
+      def get_integration_client
+        Client::IntegrationClient.new(@api_client)
+      end
+
+      def get_prompt_client
+        Client::PromptClient.new(@api_client)
+      end
+
+      def get_schema_client
+        Client::SchemaClient.new(@api_client)
+      end
+
+      def get_workflow_executor
+        Workflow::WorkflowExecutor.new(@configuration)
+      end
+    end
+  end
+end

data/lib/conductor/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Conductor
+  VERSION = '0.1.0'
+end

data/lib/conductor/worker/events/conductor_event.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Worker
+    module Events
+      # Base class for all Conductor events
+      # Provides a timestamp for when the event occurred
+      class ConductorEvent
+        # @return [Time] UTC timestamp when event was created
+        attr_reader :timestamp
+
+        def initialize
+          @timestamp = Time.now.utc
+        end
+
+        # @return [Hash] Event as a hash for serialization
+        def to_h
+          { timestamp: @timestamp.iso8601(3) }
+        end
+      end
+
+      # Base class for task runner events
+      # All events related to task polling and execution inherit from this
+      class TaskRunnerEvent < ConductorEvent
+        # @return [String] The task type/definition name
+        attr_reader :task_type
+
+        # @param task_type [String] Task definition name
+        def initialize(task_type:)
+          super()
+          @task_type = task_type
+        end
+
+        def to_h
+          super.merge(task_type: @task_type)
+        end
+      end
+    end
+  end
+end

data/lib/conductor/worker/events/global_dispatcher.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'sync_event_dispatcher'
+
+module Conductor
+  module Worker
+    module Events
+      # Process-wide default event dispatcher.
+      #
+      # Used by library layers (e.g. HTTP client) that don't have an obvious
+      # owner to receive a dispatcher reference. Listeners can subscribe to this
+      # singleton to receive events regardless of which RestClient/ApiClient
+      # instance generated them.
+      class GlobalDispatcher
+        class << self
+          def instance
+            @instance ||= SyncEventDispatcher.new
+          end
+
+          def reset!
+            @instance = SyncEventDispatcher.new
+          end
+
+          def publish(event)
+            instance.publish(event)
+          end
+
+          def http_metrics_enabled?
+            instance.has_listeners?(HttpApiRequest)
+          rescue StandardError
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/conductor/worker/events/http_events.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'conductor_event'
+
+module Conductor
+  module Worker
+    module Events
+      class HttpApiRequest < ConductorEvent
+        attr_reader :method, :uri, :status, :duration_ms
+
+        def initialize(method:, uri:, status:, duration_ms:)
+          super()
+          @method = method.to_s.upcase
+          @uri = uri.to_s
+          @status = status.to_s
+          @duration_ms = duration_ms
+        end
+
+        def to_h
+          super.merge(method: @method, uri: @uri, status: @status, duration_ms: @duration_ms)
+        end
+      end
+    end
+  end
+end

data/lib/conductor/worker/events/listener_registry.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'task_runner_events'
+require_relative 'workflow_events'
+require_relative 'http_events'
+
+module Conductor
+  module Worker
+    module Events
+      class ListenerRegistry
+        EVENT_METHOD_MAP = {
+          PollStarted => :on_poll_started,
+          PollCompleted => :on_poll_completed,
+          PollFailure => :on_poll_failure,
+          TaskExecutionStarted => :on_task_execution_started,
+          TaskExecutionCompleted => :on_task_execution_completed,
+          TaskExecutionFailure => :on_task_execution_failure,
+          TaskUpdateCompleted => :on_task_update_completed,
+          TaskUpdateFailure => :on_task_update_failure,
+          TaskPaused => :on_task_paused,
+          ThreadUncaughtException => :on_thread_uncaught_exception,
+          ActiveWorkersChanged => :on_active_workers_changed,
+          WorkflowStartError => :on_workflow_start_error,
+          WorkflowInputSize => :on_workflow_input_size,
+          HttpApiRequest => :on_http_api_request
+        }.freeze
+
+        def self.register_task_runner_listener(listener, dispatcher)
+          EVENT_METHOD_MAP.each do |event_class, method_name|
+            dispatcher.register(event_class, ->(event) { listener.send(method_name, event) }) if listener.respond_to?(method_name)
+          end
+        end
+
+        def self.register_all(listeners, dispatcher)
+          listeners.each { |listener| register_task_runner_listener(listener, dispatcher) }
+        end
+      end
+    end
+  end
+end

data/lib/conductor/worker/events/listeners.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Worker
+    module Events
+      # Listener protocol for task runner events.
+      # All methods are optional - the dispatcher uses duck typing (respond_to?).
+      module TaskRunnerEventsListener
+        def on_poll_started(event); end
+        def on_poll_completed(event); end
+        def on_poll_failure(event); end
+        def on_task_execution_started(event); end
+        def on_task_execution_completed(event); end
+        def on_task_execution_failure(event); end
+        def on_task_update_completed(event); end
+        def on_task_update_failure(event); end
+        def on_task_paused(event); end
+        def on_thread_uncaught_exception(event); end
+        def on_active_workers_changed(event); end
+      end
+
+      # Listener protocol for workflow-lifecycle events
+      module WorkflowEventsListener
+        def on_workflow_start_error(event); end
+        def on_workflow_input_size(event); end
+      end
+
+      # Listener protocol for HTTP API client events
+      module HttpEventsListener
+        def on_http_api_request(event); end
+      end
+    end
+  end
+end