standard_procedure_operations 0.5.3 → 0.7.0

data/app/jobs/operations/delete_old_task_job.rb

@@ -0,0 +1,5 @@
+class Operations::DeleteOldTaskJob < ApplicationJob
+  queue_as :default
+
+  def perform(task) = task.destroy
+end

data/app/jobs/operations/wake_task_job.rb

@@ -0,0 +1,5 @@
+class Operations::WakeTaskJob < ApplicationJob
+  queue_as :default
+
+  def perform(task) = task.wake_up!
+end

data/app/models/concerns/operations/participant.rb

@@ -3,15 +3,10 @@ module Operations
     extend ActiveSupport::Concern
 
     included do
-      has_many :operations_task_participants, class_name: "Operations::TaskParticipant", as: :participant, dependent: :destroy
-      has_many :operations_tasks, class_name: "Operations::Task", through: :operations_task_participants, source: :task
-
-      scope :involved_in_operation_as, ->(role:, context: "data") do
-        joins(:operations_task_participants).tap do |scope|
-          scope.where(operations_task_participants: {role: role}) if role
-          scope.where(operations_task_participants: {context: context}) if context
-        end
-      end
+      has_many :operations_participants, class_name: "Operations::TaskParticipant", as: :participant, dependent: :destroy
+      has_many :operations, class_name: "Operations::Task", through: :operations_participants, source: :task
     end
+
+    def operations_as(attribute_name) = operations.joins(:participants).where(participants: {attribute_name: attribute_name, participant: self})
   end
 end

data/app/models/operations/task/index.rb

@@ -0,0 +1,22 @@
+module Operations::Task::Index
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def index(*names) = @indexed_attributes = (@indexed_attributes || []) + names.map(&:to_sym)
+
+    def indexed_attributes = @indexed_attributes ||= []
+  end
+
+  included do
+    has_many :participants, class_name: "Operations::TaskParticipant", dependent: :destroy
+    after_save :update_index, if: -> { indexed_attributes.any? }
+  end
+
+  private def indexed_attributes = self.class.indexed_attributes
+  private def update_index = indexed_attributes.collect { |attribute| update_index_for(attribute) }
+  private def update_index_for(attribute)
+    models = Array.wrap(send(attribute))
+    participants.where(attribute_name: attribute).where.not(participant: models).delete_all
+    models.collect { |model| participants.where(participant: model, attribute_name: attribute).first_or_create! }
+  end
+end

data/app/models/operations/task/plan/action_handler.rb

@@ -0,0 +1,20 @@
+class Operations::Task::Plan::ActionHandler
+  attr_accessor :next_state
+
+  def initialize name, &action
+    @name = name.to_sym
+    @action = action
+    @next_state = nil
+  end
+
+  def then next_state
+    @next_state = next_state
+  end
+
+  def immediate? = true
+
+  def call(task)
+    task.instance_exec(&@action)
+    task.go_to @next_state
+  end
+end

data/app/models/operations/task/plan/decision_handler.rb

@@ -0,0 +1,40 @@
+class Operations::Task::Plan::DecisionHandler
+  def initialize name, &config
+    @name = name.to_sym
+    @conditions = []
+    @destinations = []
+    @true_state = nil
+    @false_state = nil
+    instance_eval(&config)
+  end
+
+  def immediate? = true
+
+  def condition(&condition)
+    @conditions << condition
+  end
+
+  def go_to(destination) = @destinations << destination
+
+  def if_true(state = nil, &handler) = @true_state = state || handler
+
+  def if_false(state = nil, &handler) = @false_state = state || handler
+
+  def call(task)
+    has_true_false_handlers? ? handle_single_condition(task) : handle_multiple_conditions(task)
+  end
+
+  private def has_true_false_handlers? = !@true_state.nil? || !@false_state.nil?
+
+  private def handle_single_condition(task)
+    next_state = task.instance_eval(&@conditions.first) ? @true_state : @false_state
+    task.go_to(next_state)
+  end
+
+  private def handle_multiple_conditions(task)
+    condition = @conditions.find { |condition| task.instance_eval(&condition) }
+    raise Operations::NoDecision.new("No conditions matched #{@name}") if condition.nil?
+    index = @conditions.index condition
+    task.go_to(@destinations[index])
+  end
+end

data/app/models/operations/task/plan/interaction_handler.rb

@@ -0,0 +1,20 @@
+class Operations::Task::Plan::InteractionHandler
+  def initialize name, klass, &implementation
+    @legal_states = []
+    build_method_on klass, name, self, implementation
+  end
+  attr_reader :legal_states
+
+  def when *legal_states
+    @legal_states = legal_states.map(&:to_s).freeze
+  end
+
+  private def build_method_on klass, name, handler, implementation
+    klass.define_method name.to_sym do |*args|
+      raise Operations::InvalidState.new("#{klass}##{name} cannot be called in #{current_state}") if handler.legal_states.any? && !handler.legal_states.include?(current_state.to_s)
+      Rails.logger.debug { "interaction #{name} with #{self}" }
+      instance_exec(*args, &implementation)
+      wake_up!
+    end
+  end
+end

data/app/models/operations/task/plan/result_handler.rb

@@ -0,0 +1,9 @@
+class Operations::Task::Plan::ResultHandler
+  def initialize name
+    @name = name.to_sym
+  end
+
+  def immediate? = true
+
+  def call(task) = task.update task_status: "completed", completed_at: Time.current
+end

data/app/models/operations/task/{state_management → plan}/wait_handler.rb

@@ -1,4 +1,4 @@
-class Operations::Task::StateManagement::WaitHandler
+class Operations::Task::Plan::WaitHandler
   def initialize name, &config
     @name = name.to_sym
     @conditions = []
@@ -6,6 +6,8 @@ class Operations::Task::StateManagement::WaitHandler
     instance_eval(&config)
   end
 
+  def immediate? = false
+
   def condition(options = {}, &condition)
     @conditions << condition
     @condition_labels ||= {}
@@ -17,10 +19,10 @@ class Operations::Task::StateManagement::WaitHandler
 
   def condition_labels = @condition_labels ||= {}
 
-  def call(task, data)
-    raise Operations::CannotWaitInForeground.new("#{task.class} cannot wait in the foreground", task) unless task.background?
-    condition = @conditions.find { |condition| data.instance_eval(&condition) }
-    next_state = (condition.nil? || @conditions.index(condition).nil?) ? task.state : @destinations[@conditions.index(condition)]
-    data.go_to next_state
+  def call(task)
+    Rails.logger.debug { "#{task}: waiting until #{@name}" }
+    condition = @conditions.find { |condition| task.instance_eval(&condition) }
+    next_state = (condition.nil? || @conditions.index(condition).nil?) ? task.current_state : @destinations[@conditions.index(condition)]
+    task.go_to next_state
   end
 end

data/app/models/operations/task/plan.rb

@@ -0,0 +1,70 @@
+module Operations::Task::Plan
+  extend ActiveSupport::Concern
+
+  included do
+    validate :current_state_is_legal
+  end
+
+  class_methods do
+    def starts_with(value) = @initial_state = value.to_s
+
+    def action(name, &handler) = state_handlers[name.to_s] = ActionHandler.new(name, &handler)
+
+    def decision(name, &config) = state_handlers[name.to_s] = DecisionHandler.new(name, &config)
+
+    def wait_until(name, &config) = state_handlers[name.to_s] = WaitHandler.new(name, &config)
+
+    def interaction(name, &implementation) = interaction_handlers[name.to_s] = InteractionHandler.new(name, self, &implementation)
+
+    def result(name) = state_handlers[name.to_s] = ResultHandler.new(name)
+
+    def go_to(state)
+      # Get the most recently defined action handler
+      last_action = state_handlers.values.reverse.find { |h| h.is_a?(ActionHandler) }
+      raise ArgumentError, "No action handler defined yet" unless last_action
+
+      last_action.next_state = state.to_sym
+    end
+
+    def initial_state = @initial_state || "start"
+
+    def delay(value) = @background_delay = value
+
+    def timeout(value) = @execution_timeout = value
+
+    def delete_after(value) = @deletion_time = value
+
+    def on_timeout(&handler) = @on_timeout = handler
+
+    def background_delay = @background_delay ||= 1.minute
+
+    def execution_timeout = @execution_timeout ||= 24.hours
+
+    def timeout_handler = @on_timeout
+
+    def deletion_time = @deletion_time ||= 90.days
+
+    def state_handlers = @state_handlers ||= {}
+
+    def handler_for(state) = state_handlers[state.to_s]
+
+    def interaction_handlers = @interaction_handlers ||= {}
+
+    def interaction_handler_for(name) = interaction_handlers[name.to_s]
+
+    def default_times = {wakes_at: background_delay.from_now, expires_at: execution_timeout.from_now, delete_at: deletion_time.from_now}
+  end
+
+  def in?(state) = current_state == state.to_s
+  alias_method :waiting_until?, :in?
+
+  private def handler_for(state) = self.class.handler_for(state)
+  private def default_times = self.class.default_times
+  private def background_delay = self.class.background_delay
+  private def execution_timeout = self.class.execution_timeout
+  private def timeout_handler = self.class.timeout_handler
+  private def timeout_expired? = expires_at.present? && expires_at < Time.now.utc
+  private def current_state_is_legal
+    errors.add :current_state, :invalid if current_state.blank? || handler_for(current_state).nil?
+  end
+end

data/app/models/operations/task/runner.rb

@@ -0,0 +1,34 @@
+module Operations
+  class Task::Runner
+    def initialize
+      @stopped = false
+    end
+
+    def start
+      puts "Starting #{self.class.name}"
+      register_signal_handlers
+      puts "...signal handlers registered"
+      until @stopped
+        Rails.application.eager_load! if Rails.env.development? # Ensure all sub-classes are loaded in dev mode
+        Task.wake_sleeping
+        Task.delete_old
+        sleep 30
+      end
+      puts "...stopping"
+    end
+
+    def stop
+      @stopped = true
+    end
+
+    def self.start = new.start
+
+    private def register_signal_handlers
+      %w[INT TERM].each do |signal|
+        trap(signal) { @stopped = true }
+      end
+
+      trap(:QUIT) { exit! }
+    end
+  end
+end

data/app/models/operations/task.rb

@@ -1,88 +1,70 @@
 module Operations
   class Task < ApplicationRecord
-    include StateManagement
-    include Deletion
-    include Testing
-    include Background
-    include Exports
-    extend InputValidation
+    include HasAttributes
+    include Plan
+    include Index
+    scope :ready_to_wake, -> { ready_to_wake_at(Time.current) }
+    scope :ready_to_wake_at, ->(time) { where(wakes_at: ..time) }
+    scope :expired, -> { expires_at(Time.current) }
+    scope :expired_at, ->(time) { where(expires_at: ..time) }
+    scope :ready_to_delete, -> { ready_to_delete_at(Time.current) }
+    scope :ready_to_delete_at, ->(time) { where(delete_at: ..time) }
+
+    # Task hierarchy relationships
+    belongs_to :parent, class_name: "Operations::Task", optional: true
+    has_many :sub_tasks, class_name: "Operations::Task", foreign_key: "parent_id", dependent: :nullify
+    has_many :active_sub_tasks, -> { where(status: ["active", "waiting"]) }, class_name: "Operations::Task", foreign_key: "parent_id"
+    has_many :failed_sub_tasks, -> { failed }, class_name: "Operations::Task", foreign_key: "parent_id"
+    has_many :completed_sub_tasks, -> { completed }, class_name: "Operations::Task", foreign_key: "parent_id"
+
+    enum :task_status, active: 0, waiting: 10, completed: 100, failed: -1
+    serialize :data, coder: JSON, type: Hash, default: {}
+    has_attribute :exception_class, :string
+    has_attribute :exception_message, :string
+    has_attribute :exception_backtrace, :string
+
+    def call(immediate: false)
+      while active?
+        Rails.logger.debug { "--- #{self}: #{current_state}" }
+        (handler_for(current_state).immediate? || immediate) ? handler_for(current_state).call(self) : go_to_sleep!
+      end
+    rescue => ex
+      record_error! ex
+      raise ex
+    end
 
-    enum :status, in_progress: 0, waiting: 10, completed: 100, failed: -1
+    def go_to(next_state) = update! current_state: next_state
 
-    serialize :data, coder: GlobalIdSerialiser, type: Hash, default: {}
-    serialize :results, coder: GlobalIdSerialiser, type: Hash, default: {}
+    def wake_up! = timeout_expired? ? call_timeout_handler : activate_and_call
 
-    has_many :task_participants, class_name: "Operations::TaskParticipant", dependent: :destroy
-    after_save :record_participants
+    def start(task_class, **attributes) = task_class.later(**attributes.merge(parent: self))
 
-    def call sub_task_class, **data, &result_handler
-      sub_task = sub_task_class.call(**data)
-      result_handler&.call(sub_task.results)
-      sub_task.results
-    end
+    def record_error!(exception) = update!(task_status: "failed", exception_class: exception.class.to_s, exception_message: exception.message.to_s, exception_backtrace: exception.backtrace)
+
+    private def go_to_sleep! = update!(default_times.merge(task_status: "waiting"))
 
-    def start sub_task_class, **data, &result_handler
-      sub_task_class.start(**data)
+    private def activate_and_call
+      active!
+      call(immediate: true)
     end
 
-    def perform
-      timeout!
-      in_progress!
-      handler_for(state).call(self, carrier_for(data))
+    private def call_timeout_handler
+      timeout_handler.nil? ? raise(Operations::Timeout.new("Timeout expired", self)) : timeout_handler.call
     rescue => ex
-      update! status: "failed", status_message: ex.message.to_s.truncate(240), results: {failure_message: ex.message, exception_class: ex.class.name, exception_backtrace: ex.backtrace}
+      record_error! ex
       raise ex
     end
 
-    def perform_later
-      update! status: "waiting", becomes_zombie_at: Time.now + zombie_delay
-      TaskRunnerJob.set(wait_until: background_delay.from_now).perform_later self
-    end
-    alias_method :restart!, :perform_later
+    def self.call(task_status: "active", **attributes) = create!(attributes.merge(task_status: task_status, current_state: initial_state).merge(default_times)).tap { |t| t.call }
 
-    def self.call(**)
-      build(background: false, **).tap do |task|
-        task.perform
-      end
-    end
+    def self.later(**attributes) = call(task_status: "waiting", **attributes)
 
-    def self.start(**data)
-      build(background: true, **with_timeout(data)).tap do |task|
-        task.perform_later
-      end
-    end
+    def self.perform_now(...) = call(...)
 
-    def go_to(state, data = {}, message: nil)
-      update!(state: state, data: data.to_h, status_message: (message || state).to_s.truncate(240))
-      background? ? perform_later : perform
-    end
-
-    def fail_with(message)
-      update! status: "failed", status_message: message.to_s.truncate(240), results: {failure_message: message.to_s}
-      raise Operations::Failure.new(message, self)
-    end
-
-    def complete(results) = update!(status: "completed", status_message: "completed", results: results.to_h)
-
-    private def carrier_for(data) = data.is_a?(DataCarrier) ? data : DataCarrier.new(data.merge(task: self))
+    def self.perform_later(...) = later(...)
 
-    private def record_participants
-      record_participants_in :data, data.select { |key, value| value.is_a? Participant }
-      record_participants_in :results, results.select { |key, value| value.is_a? Participant }
-    end
+    def self.wake_sleeping = Task.ready_to_wake.find_each { |t| Operations::WakeTaskJob.perform_later(t) }
 
-    private def record_participants_in context, participants
-      task_participants.where(context: context).where.not(role: participants.keys).delete_all
-      participants.each do |role, participant|
-        task_participants.where(context: context, role: role).first_or_initialize.tap do |task_participant|
-          task_participant.update! participant: participant
-        end
-      end
-    end
-
-    def self.build(background:, **data)
-      validate_inputs! data
-      create!(state: initial_state, status: background ? "waiting" : "in_progress", data: data, status_message: "", background: background)
-    end
+    def self.delete_old = Task.ready_to_delete.find_each { |t| Operations::DeleteOldTaskJob.perform_later(t) }
   end
 end

data/app/models/operations/task_participant.rb

@@ -3,10 +3,7 @@ module Operations
     belongs_to :task
     belongs_to :participant, polymorphic: true
 
-    validates :role, presence: true
-    validates :context, presence: true
-    validates :task_id, uniqueness: {scope: [:participant_type, :participant_id, :role, :context]}
-
-    scope :in, ->(context) { where(context: context) }
+    validates :attribute_name, presence: true
+    normalizes :attribute_name, with: ->(n) { n.to_s.strip }
   end
 end

data/db/migrate/20250701190516_rename_existing_operations_tables.rb

@@ -0,0 +1,19 @@
+class RenameExistingOperationsTables < ActiveRecord::Migration[8.0]
+  def up
+    remove_foreign_key :operations_task_participants, :operations_tasks, if_exists: true if table_exists?("operations_task_participants")
+
+    rename_table :operations_tasks, :operations_tasks_legacy if table_exists?("operations_tasks")
+    rename_table :operations_task_participants, :operations_task_participants_legacy if table_exists?("operations_task_participants")
+
+    add_foreign_key :operations_task_participants_legacy, :operations_tasks_legacy, column: :task_id if table_exists?("operations_task_participants_legacy")
+  end
+
+  def down
+    remove_foreign_key :operations_task_participants_legacy, :operations_tasks_legacy if table_exists?("operations_task_participants_legacy")
+
+    rename_table :operations_tasks_legacy, :operations_tasks if table_exists?("operations_task_legacy")
+    rename_table :operations_task_participants_legacy, :operations_task_participants if table_exists?("operations_task_participants_legacy")
+
+    add_foreign_key :operations_task_participants, :operations_tasks, column: :task_id if table_exists?("operations_task_participants")
+  end
+end

data/db/migrate/20250701190716_create_new_operations_tasks.rb

@@ -0,0 +1,20 @@
+class CreateNewOperationsTasks < ActiveRecord::Migration[8.0]
+  def change
+    create_table :operations_tasks do |t|
+      t.belongs_to :parent, foreign_key: {to_table: "operations_tasks"}, null: true
+      t.string :type
+      t.integer :task_status, default: 0, null: false
+      t.string :current_state, default: "start", null: false
+      t.text :data
+      t.datetime :wakes_at
+      t.datetime :expires_at
+      t.datetime :completed_at
+      t.datetime :failed_at
+      t.datetime :delete_at
+      t.timestamps
+
+      t.index [:task_status, :wakes_at], name: "operations_task_wakes_at"
+      t.index [:task_status, :delete_at], name: "operations_task_delete_at"
+    end
+  end
+end

data/db/migrate/20250702113801_create_task_participants.rb

@@ -0,0 +1,10 @@
+class CreateTaskParticipants < ActiveRecord::Migration[8.0]
+  def change
+    create_table :operations_task_participants do |t|
+      t.belongs_to :task, foreign_key: {to_table: "operations_tasks"}
+      t.belongs_to :participant, polymorphic: true, index: true
+      t.string :attribute_name, default: "", null: false
+      t.timestamps
+    end
+  end
+end

data/lib/operations/invalid_state.rb

@@ -0,0 +1,2 @@
+class Operations::InvalidState < Operations::Error
+end

data/lib/operations/version.rb

@@ -1,3 +1,3 @@
 module Operations
-  VERSION = "0.5.3"
+  VERSION = "0.7.0"
 end

data/lib/operations.rb

@@ -1,5 +1,5 @@
 require "ostruct"
-require "global_id_serialiser"
+require "has_attributes"
 
 module Operations
   class Error < StandardError
@@ -12,8 +12,7 @@ module Operations
   require "operations/version"
   require "operations/engine"
   require "operations/failure"
-  require "operations/cannot_wait_in_foreground"
   require "operations/timeout"
   require "operations/no_decision"
-  require "operations/exporters/svg"
+  require "operations/invalid_state"
 end

data/lib/tasks/operations_tasks.rake

@@ -1,4 +1,4 @@
-desc "Restart any zombie tasks"
-task :restart_zombie_tasks do
-  Operations::Task.restart_zombie_tasks
+desc "Start the Agent Runner process"
+task :agent_runner do
+  Operations::Agent::Runner.start
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: standard_procedure_operations
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.7.0
 platform: ruby
 authors:
 - Rahoul Baruah
 bindir: bin
 cert_chain: []
-date: 2025-04-04 00:00:00.000000000 Z
+date: 2025-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -24,7 +24,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 7.1.3
 - !ruby/object:Gem::Dependency
-  name: standard_procedure_global_id_serialiser
+  name: standard_procedure_has_attributes
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -48,30 +48,27 @@ files:
 - README.md
 - Rakefile
 - app/jobs/operations/application_job.rb
-- app/jobs/operations/task_runner_job.rb
+- app/jobs/operations/delete_old_task_job.rb
+- app/jobs/operations/wake_task_job.rb
 - app/models/concerns/operations/participant.rb
 - app/models/operations/task.rb
-- app/models/operations/task/background.rb
-- app/models/operations/task/data_carrier.rb
-- app/models/operations/task/deletion.rb
-- app/models/operations/task/exports.rb
-- app/models/operations/task/input_validation.rb
-- app/models/operations/task/state_management.rb
-- app/models/operations/task/state_management/action_handler.rb
-- app/models/operations/task/state_management/completion_handler.rb
-- app/models/operations/task/state_management/decision_handler.rb
-- app/models/operations/task/state_management/wait_handler.rb
-- app/models/operations/task/testing.rb
+- app/models/operations/task/index.rb
+- app/models/operations/task/plan.rb
+- app/models/operations/task/plan/action_handler.rb
+- app/models/operations/task/plan/decision_handler.rb
+- app/models/operations/task/plan/interaction_handler.rb
+- app/models/operations/task/plan/result_handler.rb
+- app/models/operations/task/plan/wait_handler.rb
+- app/models/operations/task/runner.rb
 - app/models/operations/task_participant.rb
 - config/routes.rb
-- db/migrate/20250127160616_create_operations_tasks.rb
-- db/migrate/20250309160616_create_operations_task_participants.rb
-- db/migrate/20250403075414_add_becomes_zombie_at_field.rb
+- db/migrate/20250701190516_rename_existing_operations_tables.rb
+- db/migrate/20250701190716_create_new_operations_tasks.rb
+- db/migrate/20250702113801_create_task_participants.rb
 - lib/operations.rb
-- lib/operations/cannot_wait_in_foreground.rb
 - lib/operations/engine.rb
-- lib/operations/exporters/svg.rb
 - lib/operations/failure.rb
+- lib/operations/invalid_state.rb
 - lib/operations/matchers.rb
 - lib/operations/no_decision.rb
 - lib/operations/timeout.rb

data/app/jobs/operations/task_runner_job.rb

@@ -1,11 +0,0 @@
-module Operations
-  class TaskRunnerJob < ApplicationJob
-    queue_as :default
-
-    def perform task
-      task.perform if task.waiting?
-    rescue => ex
-      Rails.logger.error "TaskRunnerJob failed: #{ex.message} for #{task.inspect}"
-    end
-  end
-end

data/app/models/operations/task/background.rb

@@ -1,39 +0,0 @@
-module Operations::Task::Background
-  extend ActiveSupport::Concern
-
-  included do
-    scope :zombies, -> { zombies_at(Time.now) }
-    scope :zombies_at, ->(time) { where(becomes_zombie_at: ..time) }
-  end
-
-  class_methods do
-    def delay(value) = @background_delay = value
-
-    def timeout(value) = @execution_timeout = value
-
-    def on_timeout(&handler) = @on_timeout = handler
-
-    def background_delay = @background_delay ||= 1.second
-
-    def execution_timeout = @execution_timeout ||= 5.minutes
-
-    def timeout_handler = @on_timeout
-
-    def with_timeout(data) = data.merge(_execution_timeout: execution_timeout.from_now.utc)
-
-    def restart_zombie_tasks = zombies.find_each { |t| t.restart! }
-  end
-
-  def zombie? = Time.now > (updated_at + zombie_delay)
-
-  private def background_delay = self.class.background_delay
-  private def zombie_delay = background_delay * 3
-  private def zombie_time = becomes_zombie_at || Time.now
-  private def execution_timeout = self.class.execution_timeout
-  private def timeout_handler = self.class.timeout_handler
-  private def timeout!
-    return unless timeout_expired?
-    timeout_handler.nil? ? raise(Operations::Timeout.new("Timeout expired", self)) : timeout_handler.call
-  end
-  private def timeout_expired? = data[:_execution_timeout].present? && data[:_execution_timeout] < Time.now.utc
-end