conductor_ruby 0.1.0

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require_relative 'base_model'
+
+module Conductor
+  module Http
+    module Models
+      # Task model representing a task in a workflow
+      class Task < BaseModel
+        SWAGGER_TYPES = {
+          task_type: 'String',
+          status: 'String',
+          input_data: 'Hash<String, Object>',
+          reference_task_name: 'String',
+          retry_count: 'Integer',
+          seq: 'Integer',
+          correlation_id: 'String',
+          poll_count: 'Integer',
+          task_def_name: 'String',
+          scheduled_time: 'Integer',
+          start_time: 'Integer',
+          end_time: 'Integer',
+          update_time: 'Integer',
+          start_delay_in_seconds: 'Integer',
+          retried_task_id: 'String',
+          retried: 'Boolean',
+          executed: 'Boolean',
+          callback_from_worker: 'Boolean',
+          response_timeout_seconds: 'Integer',
+          workflow_instance_id: 'String',
+          workflow_type: 'String',
+          task_id: 'String',
+          reason_for_incompletion: 'String',
+          callback_after_seconds: 'Integer',
+          worker_id: 'String',
+          output_data: 'Hash<String, Object>',
+          workflow_task: 'WorkflowTask',
+          domain: 'String',
+          rate_limit_per_frequency: 'Integer',
+          rate_limit_frequency_in_seconds: 'Integer',
+          external_input_payload_storage_path: 'String',
+          external_output_payload_storage_path: 'String',
+          workflow_priority: 'Integer',
+          execution_name_space: 'String',
+          isolation_group_id: 'String',
+          iteration: 'Integer',
+          sub_workflow_id: 'String',
+          subworkflow_changed: 'Boolean',
+          parent_task_id: 'String',
+          first_start_time: 'Integer',
+          loop_over_task: 'Boolean',
+          task_definition: 'TaskDef',
+          queue_wait_time: 'Integer'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          task_type: :taskType,
+          status: :status,
+          input_data: :inputData,
+          reference_task_name: :referenceTaskName,
+          retry_count: :retryCount,
+          seq: :seq,
+          correlation_id: :correlationId,
+          poll_count: :pollCount,
+          task_def_name: :taskDefName,
+          scheduled_time: :scheduledTime,
+          start_time: :startTime,
+          end_time: :endTime,
+          update_time: :updateTime,
+          start_delay_in_seconds: :startDelayInSeconds,
+          retried_task_id: :retriedTaskId,
+          retried: :retried,
+          executed: :executed,
+          callback_from_worker: :callbackFromWorker,
+          response_timeout_seconds: :responseTimeoutSeconds,
+          workflow_instance_id: :workflowInstanceId,
+          workflow_type: :workflowType,
+          task_id: :taskId,
+          reason_for_incompletion: :reasonForIncompletion,
+          callback_after_seconds: :callbackAfterSeconds,
+          worker_id: :workerId,
+          output_data: :outputData,
+          workflow_task: :workflowTask,
+          domain: :domain,
+          rate_limit_per_frequency: :rateLimitPerFrequency,
+          rate_limit_frequency_in_seconds: :rateLimitFrequencyInSeconds,
+          external_input_payload_storage_path: :externalInputPayloadStoragePath,
+          external_output_payload_storage_path: :externalOutputPayloadStoragePath,
+          workflow_priority: :workflowPriority,
+          execution_name_space: :executionNameSpace,
+          isolation_group_id: :isolationGroupId,
+          iteration: :iteration,
+          sub_workflow_id: :subWorkflowId,
+          subworkflow_changed: :subworkflowChanged,
+          parent_task_id: :parentTaskId,
+          first_start_time: :firstStartTime,
+          loop_over_task: :loopOverTask,
+          task_definition: :taskDefinition,
+          queue_wait_time: :queueWaitTime
+        }.freeze
+
+        attr_accessor :task_type, :status, :input_data, :reference_task_name,
+                      :retry_count, :seq, :correlation_id, :poll_count, :task_def_name,
+                      :scheduled_time, :start_time, :end_time, :update_time,
+                      :start_delay_in_seconds, :retried_task_id, :retried, :executed,
+                      :callback_from_worker, :response_timeout_seconds, :workflow_instance_id,
+                      :workflow_type, :task_id, :reason_for_incompletion,
+                      :callback_after_seconds, :worker_id, :output_data, :workflow_task,
+                      :domain, :rate_limit_per_frequency, :rate_limit_frequency_in_seconds,
+                      :external_input_payload_storage_path, :external_output_payload_storage_path,
+                      :workflow_priority, :execution_name_space, :isolation_group_id,
+                      :iteration, :sub_workflow_id, :subworkflow_changed, :parent_task_id,
+                      :first_start_time, :loop_over_task, :task_definition, :queue_wait_time
+
+        # Initialize a new Task
+        # @param [Hash] attributes Model attributes in the form of hash
+        def initialize(attributes = {})
+          return unless attributes.is_a?(Hash)
+
+          # Set all attributes from the hash
+          SWAGGER_TYPES.each_key do |key|
+            send("#{key}=", attributes[key]) if attributes.key?(key)
+          end
+
+          # Set default values for collections
+          @input_data ||= {}
+          @output_data ||= {}
+        end
+
+        # Check if task is in terminal state
+        # @return [Boolean] true if task is completed, failed, or cancelled
+        def terminal?
+          %w[COMPLETED FAILED FAILED_WITH_TERMINAL_ERROR CANCELED TIMED_OUT SKIPPED].include?(status)
+        end
+
+        # Check if task completed successfully
+        # @return [Boolean] true if task status is COMPLETED
+        def completed?
+          status == 'COMPLETED'
+        end
+
+        # Check if task failed
+        # @return [Boolean] true if task status is FAILED or FAILED_WITH_TERMINAL_ERROR
+        def failed?
+          %w[FAILED FAILED_WITH_TERMINAL_ERROR].include?(status)
+        end
+
+        # Check if task is in progress
+        # @return [Boolean] true if task status is IN_PROGRESS or SCHEDULED
+        def in_progress?
+          %w[IN_PROGRESS SCHEDULED].include?(status)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Retry logic options for task definitions
+      module RetryLogic
+        FIXED = 'FIXED'
+        EXPONENTIAL_BACKOFF = 'EXPONENTIAL_BACKOFF'
+        LINEAR_BACKOFF = 'LINEAR_BACKOFF'
+      end
+
+      # Timeout policy for task definitions
+      module TaskTimeoutPolicy
+        RETRY = 'RETRY'
+        TIME_OUT_WF = 'TIME_OUT_WF'
+        ALERT_ONLY = 'ALERT_ONLY'
+      end
+
+      # Task definition model for registering task types with Conductor
+      class TaskDef < BaseModel
+        SWAGGER_TYPES = {
+          name: 'String',
+          description: 'String',
+          retry_count: 'Integer',
+          timeout_seconds: 'Integer',
+          input_keys: 'Array<String>',
+          output_keys: 'Array<String>',
+          timeout_policy: 'String',
+          retry_logic: 'String',
+          retry_delay_seconds: 'Integer',
+          response_timeout_seconds: 'Integer',
+          concurrent_exec_limit: 'Integer',
+          rate_limit_per_frequency: 'Integer',
+          rate_limit_frequency_in_seconds: 'Integer',
+          isolation_group_id: 'String',
+          execution_name_space: 'String',
+          owner_email: 'String',
+          poll_timeout_seconds: 'Integer',
+          backoff_scale_factor: 'Integer'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          name: :name,
+          description: :description,
+          retry_count: :retryCount,
+          timeout_seconds: :timeoutSeconds,
+          input_keys: :inputKeys,
+          output_keys: :outputKeys,
+          timeout_policy: :timeoutPolicy,
+          retry_logic: :retryLogic,
+          retry_delay_seconds: :retryDelaySeconds,
+          response_timeout_seconds: :responseTimeoutSeconds,
+          concurrent_exec_limit: :concurrentExecLimit,
+          rate_limit_per_frequency: :rateLimitPerFrequency,
+          rate_limit_frequency_in_seconds: :rateLimitFrequencyInSeconds,
+          isolation_group_id: :isolationGroupId,
+          execution_name_space: :executionNameSpace,
+          owner_email: :ownerEmail,
+          poll_timeout_seconds: :pollTimeoutSeconds,
+          backoff_scale_factor: :backoffScaleFactor
+        }.freeze
+
+        attr_accessor :name, :description, :retry_count, :timeout_seconds,
+                      :input_keys, :output_keys, :timeout_policy, :retry_logic,
+                      :retry_delay_seconds, :response_timeout_seconds,
+                      :concurrent_exec_limit, :rate_limit_per_frequency,
+                      :rate_limit_frequency_in_seconds, :isolation_group_id,
+                      :execution_name_space, :owner_email, :poll_timeout_seconds,
+                      :backoff_scale_factor
+
+        def initialize(params = {})
+          @name = params[:name]
+          @description = params[:description]
+          @retry_count = params[:retry_count] || 3
+          @timeout_seconds = params[:timeout_seconds] || 3600
+          @input_keys = params[:input_keys] || []
+          @output_keys = params[:output_keys] || []
+          @timeout_policy = params[:timeout_policy] || TaskTimeoutPolicy::TIME_OUT_WF
+          @retry_logic = params[:retry_logic] || RetryLogic::FIXED
+          @retry_delay_seconds = params[:retry_delay_seconds] || 60
+          @response_timeout_seconds = params[:response_timeout_seconds] || 600
+          @concurrent_exec_limit = params[:concurrent_exec_limit]
+          @rate_limit_per_frequency = params[:rate_limit_per_frequency]
+          @rate_limit_frequency_in_seconds = params[:rate_limit_frequency_in_seconds]
+          @isolation_group_id = params[:isolation_group_id]
+          @execution_name_space = params[:execution_name_space]
+          @owner_email = params[:owner_email]
+          @poll_timeout_seconds = params[:poll_timeout_seconds]
+          @backoff_scale_factor = params[:backoff_scale_factor] || 1
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Task execution log entry
+      class TaskExecLog < BaseModel
+        SWAGGER_TYPES = {
+          log: 'String',
+          task_id: 'String',
+          created_time: 'Integer'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          log: :log,
+          task_id: :taskId,
+          created_time: :createdTime
+        }.freeze
+
+        attr_accessor :log, :task_id, :created_time
+
+        def initialize(params = {})
+          @log = params[:log]
+          @task_id = params[:task_id]
+          @created_time = params[:created_time]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative 'base_model'
+require_relative 'task_result_status'
+
+module Conductor
+  module Http
+    module Models
+      # TaskResult model representing the result of task execution
+      class TaskResult < BaseModel
+        SWAGGER_TYPES = {
+          workflow_instance_id: 'String',
+          task_id: 'String',
+          reason_for_incompletion: 'String',
+          callback_after_seconds: 'Integer',
+          worker_id: 'String',
+          status: 'String',
+          output_data: 'Hash<String, Object>',
+          logs: 'Array<TaskExecLog>',
+          external_output_payload_storage_path: 'String',
+          sub_workflow_id: 'String',
+          extend_lease: 'Boolean'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          workflow_instance_id: :workflowInstanceId,
+          task_id: :taskId,
+          reason_for_incompletion: :reasonForIncompletion,
+          callback_after_seconds: :callbackAfterSeconds,
+          worker_id: :workerId,
+          status: :status,
+          output_data: :outputData,
+          logs: :logs,
+          external_output_payload_storage_path: :externalOutputPayloadStoragePath,
+          sub_workflow_id: :subWorkflowId,
+          extend_lease: :extendLease
+        }.freeze
+
+        attr_accessor :workflow_instance_id, :task_id, :reason_for_incompletion,
+                      :callback_after_seconds, :worker_id, :status, :output_data,
+                      :logs, :external_output_payload_storage_path, :sub_workflow_id,
+                      :extend_lease
+
+        # Initialize a new TaskResult
+        # @param [Hash] attributes Model attributes in the form of hash
+        def initialize(attributes = {})
+          return unless attributes.is_a?(Hash)
+
+          self.workflow_instance_id = attributes[:workflow_instance_id] if attributes.key?(:workflow_instance_id)
+          self.task_id = attributes[:task_id] if attributes.key?(:task_id)
+          self.reason_for_incompletion = attributes[:reason_for_incompletion] if attributes.key?(:reason_for_incompletion)
+          self.callback_after_seconds = attributes[:callback_after_seconds] if attributes.key?(:callback_after_seconds)
+          self.worker_id = attributes[:worker_id] if attributes.key?(:worker_id)
+          self.status = attributes[:status] if attributes.key?(:status)
+          self.output_data = attributes[:output_data] || {}
+          self.logs = attributes[:logs] || []
+          if attributes.key?(:external_output_payload_storage_path)
+            self.external_output_payload_storage_path = attributes[:external_output_payload_storage_path]
+          end
+          self.sub_workflow_id = attributes[:sub_workflow_id] if attributes.key?(:sub_workflow_id)
+          self.extend_lease = attributes[:extend_lease] || false
+        end
+
+        # Add a key-value pair to output_data
+        # @param [String] key The key
+        # @param [Object] value The value
+        # @return [TaskResult] self for chaining
+        def add_output_data(key, value)
+          @output_data ||= {}
+          @output_data[key] = value
+          self
+        end
+
+        # Add a log message
+        # @param [String] log_message The log message
+        # @return [TaskResult] self for chaining
+        def log(log_message)
+          @logs ||= []
+          @logs << log_message
+          self
+        end
+
+        # Create a COMPLETED task result
+        # @return [TaskResult]
+        def self.complete
+          new(status: TaskResultStatus::COMPLETED)
+        end
+
+        # Create a FAILED task result
+        # @param [String] failure_reason Optional failure reason
+        # @return [TaskResult]
+        def self.failed(failure_reason = nil)
+          result = new(status: TaskResultStatus::FAILED)
+          result.reason_for_incompletion = failure_reason if failure_reason
+          result
+        end
+
+        # Create an IN_PROGRESS task result
+        # @return [TaskResult]
+        def self.in_progress
+          new(status: TaskResultStatus::IN_PROGRESS)
+        end
+
+        # Create a FAILED_WITH_TERMINAL_ERROR task result
+        # @param [String] failure_reason Optional failure reason
+        # @return [TaskResult]
+        def self.failed_with_terminal_error(failure_reason = nil)
+          result = new(status: TaskResultStatus::FAILED_WITH_TERMINAL_ERROR)
+          result.reason_for_incompletion = failure_reason if failure_reason
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # TaskResultStatus enum representing the status of task execution
+      module TaskResultStatus
+        COMPLETED = 'COMPLETED'
+        FAILED = 'FAILED'
+        FAILED_WITH_TERMINAL_ERROR = 'FAILED_WITH_TERMINAL_ERROR'
+        IN_PROGRESS = 'IN_PROGRESS'
+
+        ALL = [COMPLETED, FAILED, FAILED_WITH_TERMINAL_ERROR, IN_PROGRESS].freeze
+
+        # Check if the given status is valid
+        # @param [String] status The status to validate
+        # @return [Boolean] true if valid, false otherwise
+        def self.valid?(status)
+          ALL.include?(status)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'base_model'
+
+module Conductor
+  module Http
+    module Models
+      # Token model representing the authentication token response from Conductor server
+      class Token < BaseModel
+        SWAGGER_TYPES = {
+          token: 'String',
+          user_id: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          token: :token,
+          user_id: :userId
+        }.freeze
+
+        attr_accessor :token, :user_id
+
+        # Initialize a new Token
+        # @param [Hash] attributes Model attributes in the form of hash
+        def initialize(attributes = {})
+          return unless attributes.is_a?(Hash)
+
+          self.token = attributes[:token] if attributes.key?(:token)
+          self.user_id = attributes[:user_id] if attributes.key?(:user_id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # UpsertGroupRequest model - request to create or update a group
+      class UpsertGroupRequest < BaseModel
+        SWAGGER_TYPES = {
+          default_access: 'Hash<String, Array<String>>',
+          description: 'String',
+          roles: 'Array<String>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          default_access: :defaultAccess,
+          description: :description,
+          roles: :roles
+        }.freeze
+
+        attr_accessor :default_access, :description, :roles
+
+        def initialize(params = {})
+          @default_access = params[:default_access]
+          @description = params[:description]
+          @roles = params[:roles]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # User role constants
+      module UserRole
+        ADMIN = 'ADMIN'
+        USER = 'USER'
+        WORKER = 'WORKER'
+        METADATA_MANAGER = 'METADATA_MANAGER'
+        WORKFLOW_MANAGER = 'WORKFLOW_MANAGER'
+      end
+
+      # UpsertUserRequest model - request to create or update a user
+      class UpsertUserRequest < BaseModel
+        SWAGGER_TYPES = {
+          name: 'String',
+          roles: 'Array<String>',
+          groups: 'Array<String>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          name: :name,
+          roles: :roles,
+          groups: :groups
+        }.freeze
+
+        attr_accessor :name, :roles, :groups
+
+        def initialize(params = {})
+          @name = params[:name]
+          @roles = params[:roles]
+          @groups = params[:groups]
+        end
+      end
+    end
+  end
+end