standard_procedure_operations 0.5.3 → 0.6.0

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

@@ -3,7 +3,7 @@ module Operations
     extend ActiveSupport::Concern
 
     included do
-      has_many :operations_task_participants, class_name: "Operations::TaskParticipant", as: :participant, dependent: :destroy
+      has_many :operations_task_participants, -> { includes(:task).order "created_at desc" }, 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

data/app/models/operations/agent/interaction_handler.rb

@@ -0,0 +1,30 @@
+class Operations::Agent::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_sym).freeze
+  end
+
+  private def call(task, data, *args)
+    data.instance_exec(*args, &@implementation)
+  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 #{state}") if !handler.legal_states.empty? && !handler.legal_states.include?(state.to_sym)
+      Rails.logger.debug { "#{data[:task]}: interaction #{name} with #{data}" }
+      carrier_for(data).tap do |data|
+        data.instance_exec(*args, &implementation)
+        record_state_transition! data: data
+        perform
+      end
+    rescue => ex
+      record_exception(ex)
+      raise ex
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Operations::Agent::Plan
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def delay(value) = @background_delay = value
+
+    def timeout(value) = @execution_timeout = value
+
+    def on_timeout(&handler) = @on_timeout = handler
+
+    def wait_until(name, &config) = state_handlers[name.to_sym] = Operations::Agent::WaitHandler.new(name, &config)
+
+    def interaction(name, &implementation) = interaction_handlers[name.to_sym] = Operations::Agent::InteractionHandler.new(name, self, &implementation)
+
+    def background_delay = @background_delay ||= 5.minutes
+
+    def execution_timeout = @execution_timeout ||= 24.hours
+
+    def timeout_handler = @on_timeout
+
+    def interaction_handlers = @interaction_handlers ||= {}
+
+    def interaction_handler_for(name) = interaction_handlers[name.to_sym]
+  end
+
+  def timeout!
+    call_timeout_handler if timeout_expired?
+  end
+
+  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? = times_out_at.present? && times_out_at < Time.now.utc
+  private def call_timeout_handler
+    record_state_transition!
+    timeout_handler.nil? ? raise(Operations::Timeout.new("Timeout expired", self)) : timeout_handler.call
+  end
+end

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

@@ -0,0 +1,37 @@
+module Operations
+  class Agent::Runner
+    def initialize
+      @stopped = false
+    end
+
+    def start
+      puts "Starting #{self.class.name}"
+      register_signal_handlers
+      puts "...signal handlers registered"
+      until @stopped
+        process_timed_out_agents
+        process_waiting_agents
+        sleep 30
+      end
+      puts "...stopping"
+    end
+
+    def stop
+      @stopped = true
+    end
+
+    def self.start = new.start
+
+    private def process_timed_out_agents = Agent::FindTimeoutsJob.perform_later
+
+    private def process_waiting_agents = Agent::WakeAgentsJob.perform_later
+
+    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/state_management → agent}/wait_handler.rb

@@ -1,4 +1,4 @@
-class Operations::Task::StateManagement::WaitHandler
+class Operations::Agent::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 ||= {}
@@ -18,7 +20,7 @@ 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?
+    Rails.logger.debug { "#{task}: waiting until #{@name} with #{data}" }
     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

data/app/models/operations/agent.rb

@@ -0,0 +1,31 @@
+module Operations
+  class Agent < Task
+    include Plan
+    scope :ready_to_wake, -> { ready_to_wake_at(Time.now) }
+    scope :ready_to_wake_at, ->(time) { where(wakes_at: ..time) }
+    scope :timed_out, -> { timed_out_at(Time.now) }
+    scope :timed_out_at, ->(time) { where(times_out_at: ..time) }
+
+    def go_to(state, data = {}, message: nil)
+      record_state_transition! state: state, data: data.to_h, status_message: (message || state).to_s.truncate(240)
+      handler_for(state).immediate? ? perform : wait
+    end
+
+    def perform! = waiting? ? perform : nil
+
+    alias_method :waiting_until?, :is?
+
+    protected def record_state_transition! **params
+      params[:wakes_at] = Time.now.utc + background_delay
+      params[:times_out_at] ||= Time.now.utc + execution_timeout
+      super
+    end
+
+    private def wait
+      waiting!
+    rescue => ex
+      record_exception(ex)
+      raise ex
+    end
+  end
+end

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

@@ -3,8 +3,6 @@ class Operations::Task::DataCarrier < OpenStruct
 
   def call(sub_task_class, **data, &result_handler) = task.call(sub_task_class, **data, &result_handler)
 
-  def start(sub_task_class, **data, &result_handler) = task.start(sub_task_class, **data, &result_handler)
-
   def go_to(state, data = nil) = task.go_to state, data || self
 
   def complete(results) = task.complete(results)

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

@@ -9,13 +9,13 @@ module Operations::Task::Exports
 
     def handler_to_h(handler)
       case handler
-      when Operations::Task::StateManagement::DecisionHandler
+      when Operations::Task::Plan::DecisionHandler
         {type: :decision, transitions: decision_transitions(handler), inputs: extract_inputs(handler), optional_inputs: extract_optional_inputs(handler)}
-      when Operations::Task::StateManagement::ActionHandler
+      when Operations::Task::Plan::ActionHandler
         {type: :action, next_state: handler.next_state, inputs: extract_inputs(handler), optional_inputs: extract_optional_inputs(handler)}
-      when Operations::Task::StateManagement::WaitHandler
+      when Operations::Agent::WaitHandler
         {type: :wait, transitions: wait_transitions(handler), inputs: extract_inputs(handler), optional_inputs: extract_optional_inputs(handler)}
-      when Operations::Task::StateManagement::CompletionHandler
+      when Operations::Task::Plan::ResultHandler
         {type: :result, inputs: extract_inputs(handler), optional_inputs: extract_optional_inputs(handler)}
       else
         {type: :unknown}

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

@@ -1,4 +1,4 @@
-class Operations::Task::StateManagement::ActionHandler
+class Operations::Task::Plan::ActionHandler
   attr_accessor :next_state
 
   def initialize name, &action
@@ -9,6 +9,8 @@ class Operations::Task::StateManagement::ActionHandler
     @next_state = nil
   end
 
+  def immediate? = true
+
   def call(task, data)
     data.instance_exec(&@action).tap do |result|
       data.go_to @next_state unless @next_state.nil?

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

@@ -1,4 +1,4 @@
-class Operations::Task::StateManagement::DecisionHandler
+class Operations::Task::Plan::DecisionHandler
   include Operations::Task::InputValidation
 
   def initialize name, &config
@@ -10,6 +10,8 @@ class Operations::Task::StateManagement::DecisionHandler
     instance_eval(&config)
   end
 
+  def immediate? = true
+
   def condition(destination = nil, options = {}, &condition)
     @conditions << condition
     @destinations << destination if destination

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

@@ -1,4 +1,4 @@
-class Operations::Task::StateManagement::CompletionHandler
+class Operations::Task::Plan::ResultHandler
   def initialize name, inputs = [], optional = [], &handler
     @name = name.to_sym
     @required_inputs = inputs
@@ -6,6 +6,8 @@ class Operations::Task::StateManagement::CompletionHandler
     @handler = handler
   end
 
+  def immediate? = true
+
   def call(task, data)
     results = OpenStruct.new
     data.instance_exec(results, &@handler) unless @handler.nil?

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

@@ -1,4 +1,4 @@
-module Operations::Task::StateManagement
+module Operations::Task::Plan
   extend ActiveSupport::Concern
 
   included do
@@ -15,9 +15,7 @@ module Operations::Task::StateManagement
 
     def action(name, &handler) = state_handlers[name.to_sym] = ActionHandler.new(name, &handler)
 
-    def wait_until(name, &config) = state_handlers[name.to_sym] = WaitHandler.new(name, &config)
-
-    def result(name, inputs: [], optional: [], &results) = state_handlers[name.to_sym] = CompletionHandler.new(name, inputs, optional, &results)
+    def result(name, inputs: [], optional: [], &results) = state_handlers[name.to_sym] = ResultHandler.new(name, inputs, optional, &results)
 
     def go_to(state)
       # Get the most recently defined action handler

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

@@ -4,7 +4,7 @@ module Operations::Task::Testing
   class_methods do
     def handling state, background: false, **data, &block
       # Create a task specifically for testing - avoid serialization issues
-      task = new(state: state, background: background)
+      task = create!(state: state)
       # Use our own test-specific data carrier so we can examine results
       data = TestResultCarrier.new(data.merge(task: task))
 
@@ -15,6 +15,7 @@ module Operations::Task::Testing
         # Don't call super to avoid serialization
       end
 
+      task.data = data.to_h.except(:task)
       handler_for(state).call(task, data)
       data.completion_results.nil? ? block.call(data) : block.call(data.completion_results)
     end

data/app/models/operations/task.rb

@@ -1,13 +1,14 @@
 module Operations
   class Task < ApplicationRecord
-    include StateManagement
+    include Plan
     include Deletion
     include Testing
-    include Background
     include Exports
+    include HasDataAttributes
     extend InputValidation
 
     enum :status, in_progress: 0, waiting: 10, completed: 100, failed: -1
+    scope :active, -> { where(status: %w[in_progress waiting]) }
 
     serialize :data, coder: GlobalIdSerialiser, type: Hash, default: {}
     serialize :results, coder: GlobalIdSerialiser, type: Hash, default: {}
@@ -15,57 +16,77 @@ module Operations
     has_many :task_participants, class_name: "Operations::TaskParticipant", dependent: :destroy
     after_save :record_participants
 
+    def to_s = "#{model_name.human}:#{id}"
+
+    def is?(state) = self.state.to_s == state.to_s
+
+    def active? = in_progress? || waiting?
+
     def call sub_task_class, **data, &result_handler
+      Rails.logger.debug { "#{self}: call #{sub_task_class}" }
       sub_task = sub_task_class.call(**data)
       result_handler&.call(sub_task.results)
-      sub_task.results
-    end
-
-    def start sub_task_class, **data, &result_handler
-      sub_task_class.start(**data)
+      sub_task
     end
 
     def perform
-      timeout!
+      return if failed?
       in_progress!
+      Rails.logger.debug { "#{self}: performing #{state} with #{data}" }
       handler_for(state).call(self, carrier_for(data))
     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_exception(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
+    class << self
+      def call(**data)
+        validate_inputs! data
+        create!(state: initial_state, status: "in_progress", data: data, status_message: "").tap do |task|
+          task.perform
+        end
+      end
+      alias_method :start, :call
 
-    def self.call(**)
-      build(background: false, **).tap do |task|
-        task.perform
+      def inputs(*names)
+        super
+        data_attributes(*names)
       end
-    end
 
-    def self.start(**data)
-      build(background: true, **with_timeout(data)).tap do |task|
-        task.perform_later
+      def optional(*names)
+        super
+        data_attributes(*names)
       end
     end
 
     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
+      record_state_transition! state: state, data: data.to_h.except(:task), status_message: (message || state).to_s.truncate(240)
+      perform
     end
 
     def fail_with(message)
-      update! status: "failed", status_message: message.to_s.truncate(240), results: {failure_message: message.to_s}
+      Rails.logger.error { "#{self}: failed #{message}" }
       raise Operations::Failure.new(message, self)
     end
 
-    def complete(results) = update!(status: "completed", status_message: "completed", results: results.to_h)
+    def complete(results)
+      Rails.logger.debug { "#{self}: completed #{results}" }
+      update!(status: "completed", status_message: "completed", results: results.to_h)
+    end
+
+    protected def record_state_transition! **params
+      Rails.logger.debug { "#{self}: state transition to #{state}" }
+      params[:data] = params[:data].to_h.except(:task)
+      update! params
+    end
 
     private def carrier_for(data) = data.is_a?(DataCarrier) ? data : DataCarrier.new(data.merge(task: self))
 
+    private def record_exception(ex)
+      Rails.logger.error { "Exception in #{self} - #{ex.inspect}" }
+      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})
+    end
+
     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 }
@@ -79,10 +100,5 @@ module Operations
         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
   end
 end

data/app/models/operations/task_participant.rb

@@ -1,5 +1,7 @@
 module Operations
   class TaskParticipant < ApplicationRecord
+    scope :as, ->(role) { where(role: role) }
+    scope :context, ->(context) { where(context: context) }
     belongs_to :task
     belongs_to :participant, polymorphic: true
 

data/db/migrate/{20250403075414_add_becomes_zombie_at_field.rb → 20250404085321_add_becomes_zombie_at_field.operations.rb}

@@ -1,3 +1,4 @@
+# This migration comes from operations (originally 20250403075414)
 class AddBecomesZombieAtField < ActiveRecord::Migration[8.0]
   def change
     add_column :operations_tasks, :becomes_zombie_at, :datetime, null: true

data/db/migrate/20250407143513_agent_fields.rb

@@ -0,0 +1,9 @@
+class AgentFields < ActiveRecord::Migration[8.0]
+  def change
+    add_column :operations_tasks, :wakes_at, :datetime, null: true
+    add_column :operations_tasks, :times_out_at, :datetime, null: true
+    remove_column :operations_tasks, :background, :boolean, default: false, null: false
+    add_index :operations_tasks, :wakes_at
+    add_index :operations_tasks, :times_out_at
+  end
+end

data/db/migrate/20250408124423_add_task_participant_indexes.rb

@@ -0,0 +1,5 @@
+class AddTaskParticipantIndexes < ActiveRecord::Migration[8.0]
+  def change
+    add_index :operations_task_participants, [:participant_type, :participant_id, :created_at, :role, :context]
+  end
+end

data/lib/operations/has_data_attributes.rb

@@ -0,0 +1,50 @@
+# TODO: Move this into its own gem as I'm already using elsewhere
+module Operations::HasDataAttributes
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def data_attribute_in field_name, name, cast_type = :string, **options
+      name = name.to_sym
+      typecaster = cast_type.nil? ? nil : ActiveRecord::Type.lookup(cast_type)
+      typecast_value = ->(value) { typecaster.nil? ? value : typecaster.cast(value) }
+      define_attribute_method name
+      if cast_type != :boolean
+        define_method(name) { typecast_value.call(send(field_name.to_sym)[name]) || options[:default] }
+      else
+        define_method(name) do
+          value = typecast_value.call(send(field_name.to_sym)[name])
+          [true, false].include?(value) ? value : options[:default]
+        end
+        alias_method :"#{name}?", name
+      end
+      define_method(:"#{name}=") do |value|
+        attribute_will_change! name
+        send(field_name.to_sym)[name] = typecast_value.call(value)
+      end
+    end
+
+    def model_attribute_in field_name, name, class_name = nil, **options
+      id_attribute_name = :"#{name}_global_id"
+      data_attribute_in field_name, id_attribute_name, :string, **options
+
+      define_method(name.to_sym) do
+        id = send id_attribute_name.to_sym
+        id.nil? ? nil : GlobalID::Locator.locate(id)
+      rescue ActiveRecord::RecordNotFound
+        nil
+      end
+
+      define_method(:"#{name}=") do |model|
+        raise ArgumentError.new("#{model} is not #{class_name} - #{name}") if class_name.present? && model.present? && !model.is_a?(class_name.constantize)
+        id = model.nil? ? nil : model.to_global_id.to_s
+        send :"#{id_attribute_name}=", id
+      end
+    end
+
+    def data_attributes(*attributes) = attributes.each { |attribute| data_attribute(attribute) }
+
+    def data_attribute(name, cast_type = nil, **options) = data_attribute_in :data, name, cast_type, **options
+
+    def data_model(name, class_name = nil, **options) = model_attribute_in :data, name, class_name, **options
+  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.6.0"
 end

data/lib/operations.rb

@@ -9,11 +9,12 @@ module Operations
     end
     attr_reader :task
   end
+  require "operations/has_data_attributes"
   require "operations/version"
   require "operations/engine"
   require "operations/failure"
-  require "operations/cannot_wait_in_foreground"
   require "operations/timeout"
   require "operations/no_decision"
+  require "operations/invalid_state"
   require "operations/exporters/svg"
 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.6.0
 platform: ruby
 authors:
 - Rahoul Baruah
 bindir: bin
 cert_chain: []
-date: 2025-04-04 00:00:00.000000000 Z
+date: 2025-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -47,31 +47,40 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- app/jobs/operations/agent/find_timeouts_job.rb
+- app/jobs/operations/agent/runner_job.rb
+- app/jobs/operations/agent/timeout_job.rb
+- app/jobs/operations/agent/wake_agents_job.rb
 - app/jobs/operations/application_job.rb
-- app/jobs/operations/task_runner_job.rb
 - app/models/concerns/operations/participant.rb
+- app/models/operations/agent.rb
+- app/models/operations/agent/interaction_handler.rb
+- app/models/operations/agent/plan.rb
+- app/models/operations/agent/runner.rb
+- app/models/operations/agent/wait_handler.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/plan.rb
+- app/models/operations/task/plan/action_handler.rb
+- app/models/operations/task/plan/decision_handler.rb
+- app/models/operations/task/plan/result_handler.rb
 - app/models/operations/task/testing.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/20250404085321_add_becomes_zombie_at_field.operations.rb
+- db/migrate/20250407143513_agent_fields.rb
+- db/migrate/20250408124423_add_task_participant_indexes.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/has_data_attributes.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

data/lib/operations/cannot_wait_in_foreground.rb

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