Module: Tasker::Constants

Defined in:: lib/tasker/constants.rb,
lib/tasker/constants/registry_events.rb,
lib/tasker/constants/event_definitions.rb

Overview

Constants used throughout the Tasker gem

This module contains constants for workflow step and task statuses, validation states, and configuration schemas.

Event constants are generated from YAML definitions in config/tasker/system_events.yml Run rake tasker:generate_constants to regenerate after YAML changes.

Defined Under Namespace

Modules: ObservabilityEvents, RegistryEvents, StepEvents, TaskEvents, TaskExecution, TaskFinalization, TaskStatuses, TestEvents, WorkflowEvents, WorkflowStepStatuses Classes: EventDefinitions

Constant Summary collapse

VALID_WORKFLOW_STEP_STATUSES = All valid status values for workflow steps

[
  WorkflowStepStatuses::PENDING,
  WorkflowStepStatuses::IN_PROGRESS,
  WorkflowStepStatuses::ERROR,
  WorkflowStepStatuses::COMPLETE,
  WorkflowStepStatuses::CANCELLED,
  WorkflowStepStatuses::RESOLVED_MANUALLY
].freeze

UNREADY_WORKFLOW_STEP_STATUSES = Status values for steps that are not ready to be processed

[
  WorkflowStepStatuses::IN_PROGRESS,
  WorkflowStepStatuses::COMPLETE,
  WorkflowStepStatuses::CANCELLED,
  WorkflowStepStatuses::RESOLVED_MANUALLY
].freeze

VALID_TASK_STATUSES = All valid status values for tasks

[
  TaskStatuses::PENDING,
  TaskStatuses::IN_PROGRESS,
  TaskStatuses::ERROR,
  TaskStatuses::COMPLETE,
  TaskStatuses::CANCELLED,
  TaskStatuses::RESOLVED_MANUALLY
].freeze

VALID_STEP_COMPLETION_STATES = Step status values that indicate completion (success or otherwise)

[
  WorkflowStepStatuses::COMPLETE,
  WorkflowStepStatuses::RESOLVED_MANUALLY,
  WorkflowStepStatuses::CANCELLED
].freeze

VALID_STEP_STILL_WORKING_STATES = Step status values that indicate the step is still in a working state

[WorkflowStepStatuses::PENDING, WorkflowStepStatuses::IN_PROGRESS].freeze

VALID_TASK_EXECUTION_STATUSES = All valid execution status values from TaskExecutionContext view

[
  TaskExecution::ExecutionStatus::HAS_READY_STEPS,
  TaskExecution::ExecutionStatus::PROCESSING,
  TaskExecution::ExecutionStatus::BLOCKED_BY_FAILURES,
  TaskExecution::ExecutionStatus::ALL_COMPLETE,
  TaskExecution::ExecutionStatus::WAITING_FOR_DEPENDENCIES
].freeze

VALID_TASK_RECOMMENDED_ACTIONS = All valid recommended action values from TaskExecutionContext view

[
  TaskExecution::RecommendedAction::EXECUTE_READY_STEPS,
  TaskExecution::RecommendedAction::WAIT_FOR_COMPLETION,
  TaskExecution::RecommendedAction::HANDLE_FAILURES,
  TaskExecution::RecommendedAction::FINALIZE_TASK,
  TaskExecution::RecommendedAction::WAIT_FOR_DEPENDENCIES
].freeze

VALID_TASK_HEALTH_STATUSES = All valid health status values from TaskExecutionContext view

[
  TaskExecution::HealthStatus::HEALTHY,
  TaskExecution::HealthStatus::RECOVERING,
  TaskExecution::HealthStatus::BLOCKED,
  TaskExecution::HealthStatus::UNKNOWN
].freeze

ACTIONABLE_TASK_EXECUTION_STATUSES = Execution statuses that indicate the task can make immediate progress

[
  TaskExecution::ExecutionStatus::HAS_READY_STEPS
].freeze

REENQUEUE_TASK_EXECUTION_STATUSES = Execution statuses that indicate the task should be re-enqueued for later

[
  TaskExecution::ExecutionStatus::PROCESSING,
  TaskExecution::ExecutionStatus::WAITING_FOR_DEPENDENCIES
].freeze

INTERVENTION_TASK_EXECUTION_STATUSES = Execution statuses that indicate the task needs intervention

[
  TaskExecution::ExecutionStatus::BLOCKED_BY_FAILURES
].freeze

UNKNOWN = Default value for unknown identifiers

'unknown'

YAML_SCHEMA = JSON schema for validating task handler YAML configurations

{
  type: 'object',
  required: %w[name task_handler_class step_templates],
  properties: {
    name: { type: 'string' },
    module_namespace: { type: 'string', default: nil },
    task_handler_class: { type: 'string' },
    concurrent: { type: 'boolean', default: true },
    default_dependent_system: { type: 'string' },
    named_steps: {
      type: 'array',
      items: { type: 'string' }
    },
    schema: { type: 'object' },
    step_templates: {
      type: 'array',
      items: {
        type: 'object',
        required: %w[name handler_class],
        properties: {
          dependent_system: { type: 'string' },
          name: { type: 'string' },
          description: { type: 'string' },
          default_retryable: { type: 'boolean' },
          default_retry_limit: { type: 'integer' },
          skippable: { type: 'boolean' },
          handler_class: { type: 'string' },
          depends_on_step: { type: 'string' },
          depends_on_steps: {
            type: 'array',
            items: { type: 'string' }
          },
          handler_config: { type: 'object' },
          custom_events: {
            type: 'array',
            items: {
              type: 'object',
              required: %w[name],
              properties: {
                name: { type: 'string' },
                description: { type: 'string' }
              }
            }
          }
        }
      }
    },
    environments: {
      type: 'object',
      additionalProperties: {
        type: 'object',
        properties: {
          step_templates: {
            type: 'array',
            items: {
              type: 'object',
              required: %w[name],
              properties: {
                name: { type: 'string' },
                handler_config: { type: 'object' }
              }
            }
          }
        }
      }
    }
  }
}.freeze

VALID_TASK_REENQUEUE_REASONS = All valid re-enqueue reason values for task finalization

[
  TaskFinalization::ReenqueueReasons::CONTEXT_UNAVAILABLE,
  TaskFinalization::ReenqueueReasons::STEPS_IN_PROGRESS,
  TaskFinalization::ReenqueueReasons::AWAITING_DEPENDENCIES,
  TaskFinalization::ReenqueueReasons::READY_STEPS_AVAILABLE,
  TaskFinalization::ReenqueueReasons::CONTINUING_WORKFLOW,
  TaskFinalization::ReenqueueReasons::PENDING_STEPS_REMAINING,
  TaskFinalization::ReenqueueReasons::RETRY_BACKOFF
].freeze

VALID_TASK_PENDING_REASONS = All valid pending reason values for task finalization

[
  TaskFinalization::PendingReasons::CONTEXT_UNAVAILABLE,
  TaskFinalization::PendingReasons::WAITING_FOR_STEP_COMPLETION,
  TaskFinalization::PendingReasons::WAITING_FOR_DEPENDENCIES,
  TaskFinalization::PendingReasons::READY_FOR_PROCESSING,
  TaskFinalization::PendingReasons::WORKFLOW_PAUSED
].freeze

TASK_TRANSITION_EVENT_MAP = Task Transition Event Map

{
  # Initial state transitions (from nil/initial)
  [nil, TaskStatuses::PENDING] => TaskEvents::INITIALIZE_REQUESTED,
  [nil, TaskStatuses::IN_PROGRESS] => TaskEvents::START_REQUESTED,
  [nil, TaskStatuses::COMPLETE] => TaskEvents::COMPLETED,
  [nil, TaskStatuses::ERROR] => TaskEvents::FAILED,
  [nil, TaskStatuses::CANCELLED] => TaskEvents::CANCELLED,
  [nil, TaskStatuses::RESOLVED_MANUALLY] => TaskEvents::RESOLVED_MANUALLY,

  # Normal state transitions
  [TaskStatuses::PENDING,
   TaskStatuses::IN_PROGRESS] => TaskEvents::START_REQUESTED,
  [TaskStatuses::PENDING, TaskStatuses::CANCELLED] => TaskEvents::CANCELLED,
  [TaskStatuses::PENDING, TaskStatuses::ERROR] => TaskEvents::FAILED,

  [TaskStatuses::IN_PROGRESS,
   TaskStatuses::PENDING] => TaskEvents::INITIALIZE_REQUESTED,
  [TaskStatuses::IN_PROGRESS,
   TaskStatuses::COMPLETE] => TaskEvents::COMPLETED,
  [TaskStatuses::IN_PROGRESS, TaskStatuses::ERROR] => TaskEvents::FAILED,
  [TaskStatuses::IN_PROGRESS,
   TaskStatuses::CANCELLED] => TaskEvents::CANCELLED,

  [TaskStatuses::ERROR,
   TaskStatuses::PENDING] => TaskEvents::RETRY_REQUESTED,
  [TaskStatuses::ERROR,
   TaskStatuses::RESOLVED_MANUALLY] => TaskEvents::RESOLVED_MANUALLY,

  # New transitions for admin override scenarios
  [TaskStatuses::COMPLETE, TaskStatuses::CANCELLED] => TaskEvents::CANCELLED,
  [TaskStatuses::RESOLVED_MANUALLY,
   TaskStatuses::CANCELLED] => TaskEvents::CANCELLED
}.freeze