standard_procedure_operations 0.7.1 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d3727c9772fdc1cd01eb3438c01f0fdea6ea03b02e9ab631363bc20fac73ffc
-  data.tar.gz: 8d75786ef589b7029d49d743a25c7e38723124d9cf095e59cae072969a61ad0e
+  metadata.gz: 24336966a7874886f00207073fbe8f5f3f53d55bb7594c8c36d085f4c74dd369
+  data.tar.gz: 3bdf232858859b1003c7b90c911932aa5e4e7c321a0fefbcbcfc62c49801cda2
 SHA512:
-  metadata.gz: 58662325c764ab6fcbca8f047d4077a773e980bfcfda739d0a1076e8b9f5b579744de1938d2119897b33091a5de579e5d6747bd090f80a4f27a2237b287f4253
-  data.tar.gz: 1aff44b8fd34fe03bc92e1da8ab56db4f80b29cc5fc3a1e659022c2be61b8caf9ed92e23ce2572be58421f1a6ad03e96360a2f504424b1b00860a9ddd67b5d51
+  metadata.gz: 1398774410e430157a8cd45e874ca1cd631ccc3159d554d32b573d4e6f261504727b31aceaf05340c4a75f60d87309977485f163bcf79b1dc15fb7fa0a1d20d2
+  data.tar.gz: 7ee18d5f9889f902f74bc5277f71e72d1d029676bb39fe2dae7d3185accded3d3573f2b784233b21c4830b6422771ea9d47e3281975230c97eddd931c61623d2

data/README.md

@@ -9,7 +9,7 @@ In effect, that flowchart is a state machine - with "decision states" and "actio
 
 ## Breaking Change
 
-Version 0.7.0 includes breaking changes.  There are migrations which rename your existing `operations_tasks` and `operations_task_participants` tables (so the data is not deleted), then a new `operations_tasks` table is created with a simplified structure.  
+Version 0.7.0 includes breaking changes.  When you run `bin/rails operations:migrations:install` one of the migrations will drop your existing `operations_tasks` and `operations_task_participants` tables.  If you need the historic data in those tables, then edit the migration to rename the tables instead.  Also you will need to update your tests to use the new `test` method. 
 
 ## Usage
 
@@ -193,7 +193,7 @@ end
 ```
 #### Wait handlers 
 
-The registration process performs an action, `send_invitation` and then waits until a `name_provided?`.  A `wait handler` is similar to a `decision handler` but if the conditions are not met, instead of raising an error, the task goes to sleep.  A background process (see bwlow) wakes the task periodically to reevaluate the condition.  Or, an `interaction` can be triggered; this is similar to an action because it does something, but it also immediately reevaluates the current wait handler.  So in this case, when the `register!` interaction completes, the `name_provided?` wait handler is reevaluated and, because the `name` has now been supplied, it can move on to the `create_user` state.  
+The registration process performs an action, `send_invitation` and then waits until a `name_provided?`.  A `wait handler` is similar to a `decision handler` but if the conditions are not met, instead of raising an error, the task goes to sleep.  A background process (see below) wakes the task periodically to reevaluate the condition.  Or, an `interaction` can be triggered; this is similar to an action because it does something, but it also immediately reevaluates the current wait handler.  So in this case, when the `register!` interaction completes, the `name_provided?` wait handler is reevaluated and, because the `name` has now been supplied, it can move on to the `create_user` state.  
 
 When a task reaches a wait handler, it goes to sleep and expects to be woken up at some point in the future.  You can specify how often it is woken up by adding a `delay 10.minutes` declaration to your class.  The default is `1.minute`.  Likewise, if a task does not change state after a certain period it fails with an `Operations::Timeout` exception.  You can set this timeout by declaring `timeout 48.hours` (the default is `24.hours`).  
 
@@ -217,6 +217,18 @@ If you want the task to be run completely in the background (so it sleeps immedi
 
 [Example wait and interaction handlers](spec/examples/waiting_and_interactions_spec.rb)
 
+Because background tasks are woken using ActiveJob, you may wish to control exactly how these jobs are handled.  
+
+You can specify which ActiveJob queue they are placed on (with the default value being `:default`) - this is the equivalent of setting `queue_as :my_queue` in ActiveJob.  And you can even specify which queue adapter they use (if, for example, you want to use SolidQueue for most of your background jobs, but Sidekiq for a certain subset of tasks). 
+
+```ruby
+class MyBackgroundOperation < Operations::Task 
+  queue :low_priority
+  runs_on :sidekiq
+  # ...
+end
+```
+
 ### Sub tasks
 
 If your task needs to start sub-tasks, it can use the `start` method, passing the sub-task class and arguments.  
@@ -298,10 +310,10 @@ class WeekendChecker < Operations::Task
   result :weekday
 end
 
-task = WeekendChecker.verify :is_it_the_weekend?, day_of_week: "Saturday"
+task = WeekendChecker.test :is_it_the_weekend?, day_of_week: "Saturday"
 expect(task).to be_in :weekend
 
-task = WeekendChecker.verify :is_it_the_weekend?, day_of_week: "Wednesday"
+task = WeekendChecker.test :is_it_the_weekend?, day_of_week: "Wednesday"
 expect(task).to be_in :weekday
 ```
 
@@ -350,4 +362,4 @@ The gem is available as open source under the terms of the [LGPL License](/LICEN
 - [x] Add visualization export for task flows
 - [ ] Replace ActiveJob with a background process
 - [ ] Rename StateManagent with Plan
-- [ ] Add interactions
+- [ ] Add interactions

data/app/jobs/operations/wake_task_job.rb

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

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

@@ -32,6 +32,12 @@ module Operations::Task::Plan
 
     def timeout(value) = @execution_timeout = value
 
+    def queue(value) = @queue_as = value
+
+    def runs_on(value) = @queue_adapter ||= value
+    alias_method :runs, :runs_on
+    alias_method :runs_using, :runs_on
+
     def delete_after(value) = @deletion_time = value
 
     def on_timeout(&handler) = @on_timeout = handler
@@ -40,6 +46,10 @@ module Operations::Task::Plan
 
     def execution_timeout = @execution_timeout ||= 24.hours
 
+    def queue_as = @queue_as ||= :default
+
+    def queue_adapter = @queue_adapter ||= Operations::WakeTaskJob.queue_adapter
+
     def timeout_handler = @on_timeout
 
     def deletion_time = @deletion_time ||= 90.days

data/app/models/operations/task.rb

@@ -5,17 +5,18 @@ module Operations
     include Index
     include Testing
 
+    scope :active, -> { where(status: %w[active waiting]) }
     scope :ready_to_wake, -> { ready_to_wake_at(Time.current) }
-    scope :ready_to_wake_at, ->(time) { where(wakes_at: ..time) }
+    scope :ready_to_wake_at, ->(time) { waiting.where(wakes_at: ..time) }
     scope :expired, -> { expires_at(Time.current) }
-    scope :expired_at, ->(time) { where(expires_at: ..time) }
+    scope :expired_at, ->(time) { waiting.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 :active_sub_tasks, -> { active }, 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"
 
@@ -26,16 +27,18 @@ module Operations
     has_attribute :exception_backtrace, :string
 
     def call(immediate: false)
-      while active?
+      state = ""
+      while active? && (state != current_state)
+        state = current_state
         Rails.logger.debug { "--- #{self}: #{current_state}" }
-        (handler_for(current_state).immediate? || immediate) ? call_handler : go_to_sleep!
+        (immediate || state_is_immediate?(current_state)) ? call_handler : go_to_sleep!
       end
     rescue => ex
       record_error! ex
       raise ex
     end
 
-    def go_to(next_state) = update! current_state: next_state
+    def go_to(next_state) = update! current_state: next_state, task_status: (state_is_immediate?(next_state) ? "active" : "waiting")
 
     def wake_up! = timeout_expired? ? call_timeout_handler : activate_and_call
 
@@ -45,6 +48,8 @@ module Operations
 
     def call_handler = handler_for(current_state).call(self)
 
+    private def state_is_immediate?(state) = handler_for(state).immediate?
+
     private def go_to_sleep! = update!(default_times.merge(task_status: "waiting"))
 
     private def activate_and_call
@@ -59,16 +64,34 @@ module Operations
       raise ex
     end
 
-    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.later(**attributes) = call(task_status: "waiting", **attributes)
-
-    def self.perform_now(...) = call(...)
-
-    def self.perform_later(...) = later(...)
-
-    def self.wake_sleeping = Task.ready_to_wake.find_each { |t| Operations::WakeTaskJob.perform_later(t) }
+    class << self
+      def call(task_status: "active", **attributes)
+        create!(attributes.merge(task_status: task_status, current_state: initial_state).merge(default_times)).tap do |t|
+          t.call
+        end
+      end
+      alias_method :perform_now, :call
+
+      def later(**attributes) = call(task_status: "waiting", **attributes)
+      alias_method :perform_later, :later
+
+      def wake_sleeping
+        adapter = Operations::WakeTaskJob.queue_adapter
+        begin
+          Task.ready_to_wake.find_each do |task|
+            Operations::WakeTaskJob.queue_adapter = task.class.queue_adapter
+            Operations::WakeTaskJob.perform_later task
+          end
+        ensure
+          Operatives::WakeTaskJob.queue_adapter = adapter
+        end
+      end
 
-    def self.delete_old = Task.ready_to_delete.find_each { |t| Operations::DeleteOldTaskJob.perform_later(t) }
+      def delete_old
+        Task.ready_to_delete.find_each do |t|
+          Operations::DeleteOldTaskJob.perform_later(t)
+        end
+      end
+    end
   end
 end

data/lib/operations/version.rb

@@ -1,3 +1,3 @@
 module Operations
-  VERSION = "0.7.1"
+  VERSION = "0.7.3"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: standard_procedure_operations
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.3
 platform: ruby
 authors:
 - Rahoul Baruah
 bindir: bin
 cert_chain: []
-date: 2025-07-04 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -98,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Operations
 test_files: []