conductor_ruby 0.1.0

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

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Workflow execution model representing a running or completed workflow instance
+      class Workflow < BaseModel
+        SWAGGER_TYPES = {
+          workflow_id: 'String',
+          parent_workflow_id: 'String',
+          parent_workflow_task_id: 'String',
+          correlation_id: 'String',
+          workflow_name: 'String',
+          workflow_version: 'Integer',
+          workflow_definition: 'WorkflowDef',
+          status: 'String',
+          input: 'Hash<String, Object>',
+          output: 'Hash<String, Object>',
+          tasks: 'Array<Task>',
+          start_time: 'Integer',
+          end_time: 'Integer',
+          update_time: 'Integer',
+          variables: 'Hash<String, Object>',
+          external_input_payload_storage_path: 'String',
+          external_output_payload_storage_path: 'String',
+          priority: 'Integer',
+          task_to_domain: 'Hash<String, String>',
+          failed_reference_task_names: 'Array<String>',
+          reason_for_incompletion: 'String',
+          owner_app: 'String',
+          created_by: 'String',
+          event: 'String',
+          last_retried_time: 'Integer'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          workflow_id: :workflowId,
+          parent_workflow_id: :parentWorkflowId,
+          parent_workflow_task_id: :parentWorkflowTaskId,
+          correlation_id: :correlationId,
+          workflow_name: :workflowName,
+          workflow_version: :workflowVersion,
+          workflow_definition: :workflowDefinition,
+          status: :status,
+          input: :input,
+          output: :output,
+          tasks: :tasks,
+          start_time: :startTime,
+          end_time: :endTime,
+          update_time: :updateTime,
+          variables: :variables,
+          external_input_payload_storage_path: :externalInputPayloadStoragePath,
+          external_output_payload_storage_path: :externalOutputPayloadStoragePath,
+          priority: :priority,
+          task_to_domain: :taskToDomain,
+          failed_reference_task_names: :failedReferenceTaskNames,
+          reason_for_incompletion: :reasonForIncompletion,
+          owner_app: :ownerApp,
+          created_by: :createdBy,
+          event: :event,
+          last_retried_time: :lastRetriedTime
+        }.freeze
+
+        attr_accessor :workflow_id, :parent_workflow_id, :parent_workflow_task_id,
+                      :correlation_id, :workflow_name, :workflow_version,
+                      :workflow_definition, :status, :input, :output, :tasks,
+                      :start_time, :end_time, :update_time, :variables,
+                      :external_input_payload_storage_path,
+                      :external_output_payload_storage_path, :priority,
+                      :task_to_domain, :failed_reference_task_names,
+                      :reason_for_incompletion, :owner_app, :created_by,
+                      :event, :last_retried_time
+
+        def initialize(params = {})
+          @workflow_id = params[:workflow_id]
+          @parent_workflow_id = params[:parent_workflow_id]
+          @parent_workflow_task_id = params[:parent_workflow_task_id]
+          @correlation_id = params[:correlation_id]
+          @workflow_name = params[:workflow_name]
+          @workflow_version = params[:workflow_version]
+          @workflow_definition = params[:workflow_definition]
+          @status = params[:status]
+          @input = params[:input] || {}
+          @output = params[:output] || {}
+          @tasks = params[:tasks] || []
+          @start_time = params[:start_time]
+          @end_time = params[:end_time]
+          @update_time = params[:update_time]
+          @variables = params[:variables] || {}
+          @external_input_payload_storage_path = params[:external_input_payload_storage_path]
+          @external_output_payload_storage_path = params[:external_output_payload_storage_path]
+          @priority = params[:priority]
+          @task_to_domain = params[:task_to_domain]
+          @failed_reference_task_names = params[:failed_reference_task_names] || []
+          @reason_for_incompletion = params[:reason_for_incompletion]
+          @owner_app = params[:owner_app]
+          @created_by = params[:created_by]
+          @event = params[:event]
+          @last_retried_time = params[:last_retried_time]
+        end
+
+        # Check if workflow is in terminal state
+        # @return [Boolean]
+        def terminal?
+          WorkflowStatusConstants.terminal?(status)
+        end
+
+        # Check if workflow completed successfully
+        # @return [Boolean]
+        def completed?
+          status == WorkflowStatusConstants::COMPLETED
+        end
+
+        # Check if workflow failed
+        # @return [Boolean]
+        def failed?
+          status == WorkflowStatusConstants::FAILED
+        end
+
+        # Check if workflow is running
+        # @return [Boolean]
+        def running?
+          status == WorkflowStatusConstants::RUNNING
+        end
+
+        # Check if workflow is paused
+        # @return [Boolean]
+        def paused?
+          status == WorkflowStatusConstants::PAUSED
+        end
+
+        # Get a task by reference name
+        # @param ref_name [String] Task reference name
+        # @return [Task, nil]
+        def task_by_ref(ref_name)
+          tasks&.find { |t| t.reference_task_name == ref_name }
+        end
+      end
+
+      # WorkflowRun represents the result of executing a workflow synchronously
+      class WorkflowRun < BaseModel
+        SWAGGER_TYPES = {
+          workflow_id: 'String',
+          correlation_id: 'String',
+          status: 'String',
+          input: 'Hash<String, Object>',
+          output: 'Hash<String, Object>',
+          tasks: 'Array<Task>',
+          request_id: 'String',
+          created_by: 'String',
+          variables: 'Hash<String, Object>',
+          priority: 'Integer',
+          reason_for_incompletion: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          workflow_id: :workflowId,
+          correlation_id: :correlationId,
+          status: :status,
+          input: :input,
+          output: :output,
+          tasks: :tasks,
+          request_id: :requestId,
+          created_by: :createdBy,
+          variables: :variables,
+          priority: :priority,
+          reason_for_incompletion: :reasonForIncompletion
+        }.freeze
+
+        attr_accessor :workflow_id, :correlation_id, :status, :input, :output,
+                      :tasks, :request_id, :created_by, :variables, :priority,
+                      :reason_for_incompletion
+
+        def initialize(params = {})
+          @workflow_id = params[:workflow_id]
+          @correlation_id = params[:correlation_id]
+          @status = params[:status]
+          @input = params[:input] || {}
+          @output = params[:output] || {}
+          @tasks = params[:tasks] || []
+          @request_id = params[:request_id]
+          @created_by = params[:created_by]
+          @variables = params[:variables] || {}
+          @priority = params[:priority]
+          @reason_for_incompletion = params[:reason_for_incompletion]
+        end
+
+        # Check if workflow completed successfully
+        # @return [Boolean]
+        def completed?
+          status == WorkflowStatusConstants::COMPLETED
+        end
+
+        # Check if workflow is still running
+        # @return [Boolean]
+        def running?
+          status == WorkflowStatusConstants::RUNNING
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Workflow definition model for registering workflows with Conductor
+      class WorkflowDef < BaseModel
+        SWAGGER_TYPES = {
+          name: 'String',
+          description: 'String',
+          version: 'Integer',
+          tasks: 'Array<WorkflowTask>',
+          input_parameters: 'Array<String>',
+          output_parameters: 'Hash<String, Object>',
+          failure_workflow: 'String',
+          schema_version: 'Integer',
+          restartable: 'Boolean',
+          workflow_status_listener_enabled: 'Boolean',
+          workflow_status_listener_sink: 'String',
+          owner_email: 'String',
+          timeout_policy: 'String',
+          timeout_seconds: 'Integer',
+          variables: 'Hash<String, Object>',
+          input_template: 'Hash<String, Object>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          name: :name,
+          description: :description,
+          version: :version,
+          tasks: :tasks,
+          input_parameters: :inputParameters,
+          output_parameters: :outputParameters,
+          failure_workflow: :failureWorkflow,
+          schema_version: :schemaVersion,
+          restartable: :restartable,
+          workflow_status_listener_enabled: :workflowStatusListenerEnabled,
+          workflow_status_listener_sink: :workflowStatusListenerSink,
+          owner_email: :ownerEmail,
+          timeout_policy: :timeoutPolicy,
+          timeout_seconds: :timeoutSeconds,
+          variables: :variables,
+          input_template: :inputTemplate
+        }.freeze
+
+        attr_accessor :name, :description, :version, :tasks, :input_parameters,
+                      :output_parameters, :failure_workflow, :schema_version,
+                      :restartable, :workflow_status_listener_enabled,
+                      :workflow_status_listener_sink, :owner_email, :timeout_policy,
+                      :timeout_seconds, :variables, :input_template
+
+        def initialize(params = {})
+          @name = params[:name]
+          @description = params[:description]
+          @version = params[:version]
+          @tasks = params[:tasks] || []
+          @input_parameters = params[:input_parameters] || []
+          @output_parameters = params[:output_parameters] || {}
+          @failure_workflow = params[:failure_workflow]
+          @schema_version = params[:schema_version] || 2
+          @restartable = params[:restartable].nil? ? true : params[:restartable]
+          @workflow_status_listener_enabled = params[:workflow_status_listener_enabled] || false
+          @workflow_status_listener_sink = params[:workflow_status_listener_sink]
+          @owner_email = params[:owner_email]
+          @timeout_policy = params[:timeout_policy]
+          @timeout_seconds = params[:timeout_seconds] || 60
+          @variables = params[:variables] || {}
+          @input_template = params[:input_template] || {}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Workflow schedule definition
+      class SaveScheduleRequest < BaseModel
+        SWAGGER_TYPES = {
+          name: 'String',
+          cron_expression: 'String',
+          start_workflow_request: 'StartWorkflowRequest',
+          paused: 'Boolean',
+          run_catchup_schedule_instances: 'Boolean',
+          schedule_start_time: 'Integer',
+          schedule_end_time: 'Integer',
+          created_by: 'String',
+          updated_by: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          name: :name,
+          cron_expression: :cronExpression,
+          start_workflow_request: :startWorkflowRequest,
+          paused: :paused,
+          run_catchup_schedule_instances: :runCatchupScheduleInstances,
+          schedule_start_time: :scheduleStartTime,
+          schedule_end_time: :scheduleEndTime,
+          created_by: :createdBy,
+          updated_by: :updatedBy
+        }.freeze
+
+        attr_accessor :name, :cron_expression, :start_workflow_request, :paused,
+                      :run_catchup_schedule_instances, :schedule_start_time,
+                      :schedule_end_time, :created_by, :updated_by
+
+        def initialize(params = {})
+          @name = params[:name]
+          @cron_expression = params[:cron_expression]
+          @start_workflow_request = params[:start_workflow_request]
+          @paused = params.fetch(:paused, false)
+          @run_catchup_schedule_instances = params.fetch(:run_catchup_schedule_instances, false)
+          @schedule_start_time = params[:schedule_start_time]
+          @schedule_end_time = params[:schedule_end_time]
+          @created_by = params[:created_by]
+          @updated_by = params[:updated_by]
+        end
+      end
+
+      # Workflow schedule (returned from server)
+      class WorkflowSchedule < BaseModel
+        SWAGGER_TYPES = {
+          name: 'String',
+          cron_expression: 'String',
+          start_workflow_request: 'StartWorkflowRequest',
+          paused: 'Boolean',
+          run_catchup_schedule_instances: 'Boolean',
+          schedule_start_time: 'Integer',
+          schedule_end_time: 'Integer',
+          create_time: 'Integer',
+          updated_time: 'Integer',
+          created_by: 'String',
+          updated_by: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          name: :name,
+          cron_expression: :cronExpression,
+          start_workflow_request: :startWorkflowRequest,
+          paused: :paused,
+          run_catchup_schedule_instances: :runCatchupScheduleInstances,
+          schedule_start_time: :scheduleStartTime,
+          schedule_end_time: :scheduleEndTime,
+          create_time: :createTime,
+          updated_time: :updatedTime,
+          created_by: :createdBy,
+          updated_by: :updatedBy
+        }.freeze
+
+        attr_accessor :name, :cron_expression, :start_workflow_request, :paused,
+                      :run_catchup_schedule_instances, :schedule_start_time,
+                      :schedule_end_time, :create_time, :updated_time,
+                      :created_by, :updated_by
+
+        def initialize(params = {})
+          @name = params[:name]
+          @cron_expression = params[:cron_expression]
+          @start_workflow_request = params[:start_workflow_request]
+          @paused = params.fetch(:paused, false)
+          @run_catchup_schedule_instances = params.fetch(:run_catchup_schedule_instances, false)
+          @schedule_start_time = params[:schedule_start_time]
+          @schedule_end_time = params[:schedule_end_time]
+          @create_time = params[:create_time]
+          @updated_time = params[:updated_time]
+          @created_by = params[:created_by]
+          @updated_by = params[:updated_by]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Request to update workflow state (variables and/or task state)
+      class WorkflowStateUpdate < BaseModel
+        SWAGGER_TYPES = {
+          task_reference_name: 'String',
+          task_result: 'TaskResult',
+          variables: 'Hash<String, Object>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          task_reference_name: :taskReferenceName,
+          task_result: :taskResult,
+          variables: :variables
+        }.freeze
+
+        attr_accessor :task_reference_name, :task_result, :variables
+
+        def initialize(params = {})
+          @task_reference_name = params[:task_reference_name]
+          @task_result = params[:task_result]
+          @variables = params[:variables] || {}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # WorkflowStatus constants and helper methods
+      module WorkflowStatusConstants
+        # Status values
+        RUNNING = 'RUNNING'
+        COMPLETED = 'COMPLETED'
+        FAILED = 'FAILED'
+        TIMED_OUT = 'TIMED_OUT'
+        TERMINATED = 'TERMINATED'
+        PAUSED = 'PAUSED'
+
+        ALL = [RUNNING, COMPLETED, FAILED, TIMED_OUT, TERMINATED, PAUSED].freeze
+
+        # Terminal statuses - workflow has ended
+        TERMINAL_STATUSES = [COMPLETED, FAILED, TIMED_OUT, TERMINATED].freeze
+
+        # Successful statuses
+        SUCCESSFUL_STATUSES = [PAUSED, COMPLETED].freeze
+
+        # Running statuses
+        RUNNING_STATUSES = [RUNNING, PAUSED].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
+
+        # Check if status is terminal (workflow has ended)
+        # @param [String] status The status to check
+        # @return [Boolean] true if terminal, false otherwise
+        def self.terminal?(status)
+          TERMINAL_STATUSES.include?(status)
+        end
+
+        # Check if status is successful
+        # @param [String] status The status to check
+        # @return [Boolean] true if successful, false otherwise
+        def self.successful?(status)
+          SUCCESSFUL_STATUSES.include?(status)
+        end
+
+        # Check if status is running
+        # @param [String] status The status to check
+        # @return [Boolean] true if running, false otherwise
+        def self.running?(status)
+          RUNNING_STATUSES.include?(status)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Represents a workflow task definition within a workflow
+      # Used for serialization to/from JSON when registering workflows
+      class WorkflowTask < BaseModel
+        SWAGGER_TYPES = {
+          name: 'String',
+          task_reference_name: 'String',
+          type: 'String',
+          description: 'String',
+          optional: 'Boolean',
+          input_parameters: 'Hash<String, Object>',
+          dynamic_task_name_param: 'String',
+          case_value_param: 'String',
+          case_expression: 'String',
+          script_expression: 'String',
+          decision_cases: 'Hash<String, Array<WorkflowTask>>',
+          dynamic_fork_join_tasks_param: 'String',
+          dynamic_fork_tasks_param: 'String',
+          dynamic_fork_tasks_input_param_name: 'String',
+          default_case: 'Array<WorkflowTask>',
+          fork_tasks: 'Array<Array<WorkflowTask>>',
+          start_delay: 'Integer',
+          sub_workflow_param: 'SubWorkflowParams',
+          join_on: 'Array<String>',
+          sink: 'String',
+          task_definition: 'Object',
+          rate_limited: 'Boolean',
+          default_exclusive_join_task: 'Array<String>',
+          async_complete: 'Boolean',
+          loop_condition: 'String',
+          loop_over: 'Array<WorkflowTask>',
+          retry_count: 'Integer',
+          evaluator_type: 'String',
+          expression: 'String',
+          workflow_task_type: 'String',
+          cache_config: 'CacheConfig'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          name: :name,
+          task_reference_name: :taskReferenceName,
+          type: :type,
+          description: :description,
+          optional: :optional,
+          input_parameters: :inputParameters,
+          dynamic_task_name_param: :dynamicTaskNameParam,
+          case_value_param: :caseValueParam,
+          case_expression: :caseExpression,
+          script_expression: :scriptExpression,
+          decision_cases: :decisionCases,
+          dynamic_fork_join_tasks_param: :dynamicForkJoinTasksParam,
+          dynamic_fork_tasks_param: :dynamicForkTasksParam,
+          dynamic_fork_tasks_input_param_name: :dynamicForkTasksInputParamName,
+          default_case: :defaultCase,
+          fork_tasks: :forkTasks,
+          start_delay: :startDelay,
+          sub_workflow_param: :subWorkflowParam,
+          join_on: :joinOn,
+          sink: :sink,
+          task_definition: :taskDefinition,
+          rate_limited: :rateLimited,
+          default_exclusive_join_task: :defaultExclusiveJoinTask,
+          async_complete: :asyncComplete,
+          loop_condition: :loopCondition,
+          loop_over: :loopOver,
+          retry_count: :retryCount,
+          evaluator_type: :evaluatorType,
+          expression: :expression,
+          workflow_task_type: :workflowTaskType,
+          cache_config: :cacheConfig
+        }.freeze
+
+        attr_accessor :name, :task_reference_name, :type, :description, :optional,
+                      :input_parameters, :dynamic_task_name_param, :case_value_param,
+                      :case_expression, :script_expression, :decision_cases,
+                      :dynamic_fork_join_tasks_param, :dynamic_fork_tasks_param,
+                      :dynamic_fork_tasks_input_param_name, :default_case, :fork_tasks,
+                      :start_delay, :sub_workflow_param, :join_on, :sink,
+                      :task_definition, :rate_limited, :default_exclusive_join_task,
+                      :async_complete, :loop_condition, :loop_over, :retry_count,
+                      :evaluator_type, :expression, :workflow_task_type, :cache_config
+
+        def initialize(params = {})
+          @name = params[:name]
+          @task_reference_name = params[:task_reference_name]
+          @type = params[:type]
+          @description = params[:description]
+          @optional = params[:optional]
+          @input_parameters = params[:input_parameters] || {}
+          @dynamic_task_name_param = params[:dynamic_task_name_param]
+          @case_value_param = params[:case_value_param]
+          @case_expression = params[:case_expression]
+          @script_expression = params[:script_expression]
+          @decision_cases = params[:decision_cases]
+          @dynamic_fork_join_tasks_param = params[:dynamic_fork_join_tasks_param]
+          @dynamic_fork_tasks_param = params[:dynamic_fork_tasks_param]
+          @dynamic_fork_tasks_input_param_name = params[:dynamic_fork_tasks_input_param_name]
+          @default_case = params[:default_case]
+          @fork_tasks = params[:fork_tasks]
+          @start_delay = params[:start_delay]
+          @sub_workflow_param = params[:sub_workflow_param]
+          @join_on = params[:join_on]
+          @sink = params[:sink]
+          @task_definition = params[:task_definition]
+          @rate_limited = params[:rate_limited]
+          @default_exclusive_join_task = params[:default_exclusive_join_task]
+          @async_complete = params[:async_complete]
+          @loop_condition = params[:loop_condition]
+          @loop_over = params[:loop_over]
+          @retry_count = params[:retry_count]
+          @evaluator_type = params[:evaluator_type]
+          @expression = params[:expression]
+          @workflow_task_type = params[:workflow_task_type]
+          @cache_config = params[:cache_config]
+        end
+      end
+
+      # Cache configuration for tasks
+      class CacheConfig < BaseModel
+        SWAGGER_TYPES = {
+          key: 'String',
+          ttl_in_second: 'Integer'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          key: :key,
+          ttl_in_second: :ttlInSecond
+        }.freeze
+
+        attr_accessor :key, :ttl_in_second
+
+        def initialize(params = {})
+          @key = params[:key]
+          @ttl_in_second = params[:ttl_in_second]
+        end
+      end
+
+      # Sub-workflow parameters for SUB_WORKFLOW tasks
+      class SubWorkflowParams < BaseModel
+        SWAGGER_TYPES = {
+          name: 'String',
+          version: 'Integer',
+          task_to_domain: 'Hash<String, String>',
+          workflow_definition: 'WorkflowDef'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          name: :name,
+          version: :version,
+          task_to_domain: :taskToDomain,
+          workflow_definition: :workflowDefinition
+        }.freeze
+
+        attr_accessor :name, :version, :task_to_domain, :workflow_definition
+
+        def initialize(params = {})
+          @name = params[:name]
+          @version = params[:version]
+          @task_to_domain = params[:task_to_domain]
+          @workflow_definition = params[:workflow_definition]
+        end
+      end
+    end
+  end
+end