stepper_motor 0.1.7 → 0.1.8

data/lib/generators/stepper_motor_migration_004.rb.erb

@@ -0,0 +1,26 @@
+class StepperMotorMigration004 < ActiveRecord::Migration[<%= migration_version %>]
+  def up
+    quoted_false = connection.quote(false)
+    add_index :stepper_motor_journeys, [:type, :hero_id, :hero_type], 
+              where: "allow_multiple = '#{quoted_false}' AND state IN ('ready', 'performing', 'paused')", 
+              unique: true, 
+              name: :idx_journeys_one_per_hero_with_paused
+
+    # Remove old indexes that only include 'ready' state
+    remove_index :stepper_motor_journeys, [:next_step_to_be_performed_at], where: "state = 'ready'"
+    remove_index :stepper_motor_journeys, [:type, :hero_id, :hero_type], name: :one_per_hero_index, where: "allow_multiple = '0' AND state IN ('ready', 'performing')"
+  end
+
+  def down
+    # Recreate old indexes
+    add_index :stepper_motor_journeys, [:next_step_to_be_performed_at], where: "state = 'ready'"
+    quoted_false = connection.quote(false)
+    add_index :stepper_motor_journeys, [:type, :hero_id, :hero_type], 
+              where: "allow_multiple = '#{quoted_false}' AND state IN ('ready', 'performing')", 
+              unique: true, 
+              name: :one_per_hero_index
+
+    # Remove new indexes
+    remove_index :stepper_motor_journeys, name: :idx_journeys_one_per_hero_with_paused
+  end
+end 

data/lib/stepper_motor/forward_scheduler.rb

@@ -6,17 +6,21 @@
 # option if your ActiveJob adapter supports far-ahead scheduling. Some adapters,
 # such as SQS, have limitations regarding the maximum delay after which a message
 # will become visible. For SQS, the limit is 900 seconds. If the job is further in the future,
-# it is likely going to fail to get enqueued. If you are working with a queue adapter
-# either:
+# it is likely going to fail to get enqueued. If you are working with a queue adapter that:
 #
 # * Does not allow easy introspection of jobs in the future (like Redis-based queues)
 # * Limits the value of the `wait:` parameter
 #
-# this scheduler is not a good fit for you, and you will need to use the {CyclicScheduler} instead.
+# this scheduler may not be a good fit for you, and you will need to use the {CyclicScheduler} instead.
+# Note that this scheduler is also likely to populate your queue with a high number of "far out"
+# jobs to be performed in the future. Different ActiveJob adapters are known to have varying
+# performance depending on the number of jobs in the queue. For example, good_job is known to
+# struggle a bit if the queue contains a large number of jobs (even if those jobs are not yet
+# scheduled to be performed). For good_job the {CyclicScheduler} is also likely to be a better option.
 class StepperMotor::ForwardScheduler
   def schedule(journey)
     StepperMotor::PerformStepJobV2
       .set(wait_until: journey.next_step_to_be_performed_at)
-      .perform_later(journey_id: journey.id, journey_class_name: journey.class.to_s)
+      .perform_later(journey_id: journey.id, journey_class_name: journey.class.to_s, idempotency_key: journey.idempotency_key)
   end
 end

data/lib/stepper_motor/journey/flow_control.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module StepperMotor::Journey::FlowControl
+  # Is a convenient way to end a hero's journey. Imagine you enter a step where you are inviting a user
+  # to rejoin the platform, and are just about to send them an email - but they have already joined. You
+  # can therefore cancel their journey. Canceling bails you out of the `step`-defined block and sets the journey record to the `canceled` state.
+  #
+  # Calling `cancel!` within a step will abort the execution of the current step.
+  #
+  # @return void
+  def cancel!
+    canceled!
+    throw :abort_step if @current_step_definition
+  end
+
+  # Inside a step it is possible to ask StepperMotor to retry to start the step at a later point in time. Maybe now is an inconvenient moment
+  # (are you about to send a push notification at 3AM perhaps?). The `wait:` parameter specifies how long to defer reattempting the step for.
+  # Reattempting will resume the step from the beginning, so the step should be idempotent.
+  #
+  # `reattempt!` may only be called within a step.
+  #
+  # @return void
+  def reattempt!(wait: nil)
+    raise "reattempt! can only be called within a step" unless @current_step_definition
+    # The default `wait` is the one for the step definition
+    @reattempt_after = wait || @current_step_definition.wait || 0
+    throw :abort_step if @current_step_definition
+  end
+
+  # Is used to pause a Journey at any point. The "paused" state is similar to the "ready" state, except that "perform_next_step!" on the
+  # journey will do nothing - even if it is scheduled to be performed. Pausing a Journey can be useful in the following situations:
+  #
+  # * The hero of the journey is in a compliance procedure, and their Journeys should not continue
+  # * The external resource a Journey will be calling is not available
+  # * There is a bug in the Journey implementation and you need some time to get it fixed without canceling or recreating existing Journeys
+  #
+  # Calling `pause!` within a step will abort the execution of the current step.
+  #
+  # @return void
+  def pause!
+    paused!
+    throw :abort_step if @current_step_definition
+  end
+
+  # Is used to resume a paused Journey. It places the Journey into the `ready` state and schedules the job to perform that step.
+  #
+  # Calling `resume!` is only permitted outside of a step
+  #
+  # @return void
+  def resume!
+    raise "resume! can only be used outside of a step" if @current_step_definition
+    with_lock do
+      raise "The #{self.class} to resume must be in the `paused' state, but was in #{state.inspect}" unless paused?
+      update!(state: "ready", idempotency_key: SecureRandom.base36(16))
+      schedule!
+    end
+  end
+end

data/lib/stepper_motor/journey/recovery.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module StepperMotor::Journey::Recovery
+  extend ActiveSupport::Concern
+
+  included do
+    # Allows querying for Journeys which are stuck in "performing" state since a certain
+    # timestamp. These Journeys have likely been stuck because the worker that was performing
+    # the step has crashed or was forcibly restarted.
+    scope :stuck, ->(since) {
+      where(updated_at: ..since).performing
+    }
+
+    # Sets the behavior when a Journey gets stuck in "performing" state. The default us "reattempt" -
+    # it is going to try to restart the step the Journey got stuck on
+    class_attribute :when_stuck, default: :reattempt, instance_accessor: false, instance_reader: true
+  end
+
+  def recover!
+    case when_stuck
+    when :reattempt
+      with_lock do
+        return unless performing?
+        ready!
+        schedule!
+      end
+    else
+      with_lock do
+        return unless performing?
+        canceled!
+      end
+    end
+  end
+end

data/lib/stepper_motor/journey.rb

@@ -14,17 +14,17 @@ module StepperMotor
   #         ReinviteMailer.with(recipient: hero).deliver_later
   #       end
   #
-  #       step, wait: 3.days do
+  #       step wait: 3.days do
   #         cancel! if hero.active?
   #         ReinviteMailer.with(recipient: hero).deliver_later
   #       end
   #
-  #       step, wait: 3.days do
+  #       step wait: 3.days do
   #         cancel! if hero.active?
   #         ReinviteMailer.with(recipient: hero).deliver_later
   #       end
   #
-  #       step, wait: 3.days do
+  #       step wait: 3.days do
   #         cancel! if hero.active?
   #         hero.close_account!
   #       end
@@ -36,14 +36,20 @@ module StepperMotor
   #
   # To stop the journey forcibly, delete it from your database - or call `cancel!` within any of the steps.
   class Journey < ActiveRecord::Base
+    require_relative "journey/flow_control"
+    include StepperMotor::Journey::FlowControl
+
+    require_relative "journey/recovery"
+    include StepperMotor::Journey::Recovery
+
     self.table_name = "stepper_motor_journeys"
 
-    # @return [Array] the step definitions defined so far
+    # @return [Array<StepperMotor::Step>] the step definitions defined so far
     class_attribute :step_definitions, default: []
 
     belongs_to :hero, polymorphic: true, optional: true
 
-    STATES = %w[ready performing canceled finished]
+    STATES = %w[ready paused performing canceled finished]
     enum :state, STATES.zip(STATES).to_h, default: "ready"
 
     # Allows querying for journeys for this specific hero. This uses a scope for convenience as the hero
@@ -52,40 +58,29 @@ module StepperMotor
       where(hero: hero)
     }
 
-    # Allows querying for Journeys which are stuck in "performing" state since a certain
-    # timestamp. These Journeys have likely been stuck because the worker that was performing
-    # the step has crashed or was forcibly restarted.
-    scope :stuck, ->(since) {
-      where(updated_at: ..since).performing
-    }
-
-    # Sets the behavior when a Journey gets stuck in "performing" state. The default us "reattempt" -
-    # it is going to try to restart the step the Journey got stuck on
-    class_attribute :when_stuck, default: :reattempt, instance_accessor: false, instance_reader: true
-
-    def recover!
-      case when_stuck
-      when :reattempt
-        with_lock do
-          return unless performing?
-          ready!
-          schedule!
-        end
-      else
-        with_lock do
-          return unless performing?
-          canceled!
-        end
-      end
-    end
-
     after_create do |journey|
       journey.step_definitions.any? ? journey.set_next_step_and_enqueue(journey.step_definitions.first) : journey.finished!
     end
 
     # Defines a step in the journey.
     # Steps are stacked top to bottom and get performed in sequence.
-    def self.step(name = nil, wait: nil, after: nil, &blk)
+    #
+    # @param name[String,nil] the name of the step. If none is provided, a name will be automatically generated based
+    #    on the position of the step in the list of `step_definitions`. The name can also be used to call a method
+    #    on the `Journey` instead of calling the provided block.
+    # @param wait[Float,#to_f,ActiveSupport::Duration] the amount of time this step should wait before getting performed.
+    #    When the journey gets scheduled, the triggering job is going to be delayed by this amount of time, and the
+    #    `next_step_to_be_performed_at` attribute will be set to the current time plus the wait duration. Mutually exclusive with `after:`
+    # @param after[Float,#to_f,ActiveSupport::Duration] the amount of time this step should wait before getting performed
+    #    including all the previous waits. This allows you to set the wait time based on the time after the journey started, as opposed
+    #    to when the previous step has completed. When the journey gets scheduled, the triggering job is going to be delayed by this
+    #    amount of time _minus the `wait` values of the preceding steps, and the
+    #    `next_step_to_be_performed_at` attribute will be set to the current time. The `after` value gets converted into the `wait`
+    #    value and passed to the step definition. Mutually exclusive with `wait:`
+    # @param on_exception[Symbol] See {StepperMotor::Step#on_exception}
+    # @param additional_step_definition_options Any remaining options get passed to `StepperMotor::Step.new` as keyword arguments.
+    # @return [StepperMotor::Step] the step definition that has been created
+    def self.step(name = nil, wait: nil, after: nil, on_exception: :pause!, **additional_step_definition_options, &blk)
       wait = if wait && after
         raise StepConfigurationError, "Either wait: or after: can be specified, but not both"
       elsif !wait && !after
@@ -97,6 +92,16 @@ module StepperMotor
         wait
       end
       raise StepConfigurationError, "wait: cannot be negative, but computed was #{wait}s" if wait.negative?
+
+      if name.blank? && blk.blank?
+        raise StepConfigurationError, <<~MSG
+          Step #{step_definitions.length + 1} of #{self} has no explicit name,
+          and no block with step definition has been provided. Without a name the step
+          must be defined with a block to execute. If you want an instance method to be
+          executed as a step, pass the name of the method as the name of the step.
+        MSG
+      end
+
       name ||= "step_%d" % (step_definitions.length + 1)
       name = name.to_s
 
@@ -104,12 +109,12 @@ module StepperMotor
       raise StepConfigurationError, "Step named #{name.inspect} already defined" if known_step_names.include?(name)
 
       # Create the step definition
-      step_definition = StepperMotor::Step.new(name: name, wait: wait, seq: step_definitions.length, &blk)
-
-      # As per Rails docs: you need to be aware when using class_attribute with mutable structures
-      # as Array or Hash. In such cases, you don’t want to do changes in place. Instead use setters.
-      # See https://apidock.com/rails/v7.1.3.2/Class/class_attribute
-      self.step_definitions = step_definitions + [step_definition]
+      StepperMotor::Step.new(name: name, wait: wait, seq: step_definitions.length, on_exception:, **additional_step_definition_options, &blk).tap do |step_definition|
+        # As per Rails docs: you need to be aware when using class_attribute with mutable structures
+        # as Array or Hash. In such cases, you don't want to do changes in place. Instead use setters.
+        # See https://apidock.com/rails/v7.1.3.2/Class/class_attribute
+        self.step_definitions = step_definitions + [step_definition]
+      end
     end
 
     # Returns the `Step` object for a named step. This is used when performing a step, but can also
@@ -135,27 +140,6 @@ module StepperMotor
       self.class.lookup_step_definition(by_step_name)
     end
 
-    # Is a convenient way to end a hero's journey. Imagine you enter a step where you are inviting a user
-    # to rejoin the platform, and are just about to send them an email - but they have already joined. You
-    # can therefore cancel their journey. Canceling bails you out of the `step`-defined block and sets the journey record to the `canceled` state.
-    #
-    # Calling `cancel!` will abort the execution of the current step.
-    def cancel!
-      canceled!
-      throw :abort_step
-    end
-
-    # Inside a step it is possible to ask StepperMotor to retry to start the step at a later point in time. Maybe now is an inconvenient moment
-    # (are you about to send a push notification at 3AM perhaps?). The `wait:` parameter specifies how long to defer reattempting the step for.
-    # Reattempting will resume the step from the beginning, so the step should be idempotent.
-    #
-    # Calling `reattempt!` will abort the execution of the current step.
-    def reattempt!(wait: nil)
-      # The default `wait` is the one for the step definition
-      @reattempt_after = wait || @current_step_definition.wait || 0
-      throw :abort_step
-    end
-
     # Performs the next step in the journey. Will check whether any other process has performed the step already
     # and whether the record is unchanged, and will then lock it and set the state to 'performimg'.
     #
@@ -163,13 +147,18 @@ module StepperMotor
     # the step another `PerformStepJob` may get enqueued. If the journey ends here, the journey record will set its state
     # to 'finished'.
     #
+    # @param idempotency_key [String, nil] If provided, the step will only be performed if the idempotency key matches the current idempotency key.
+    #   This ensures that the only the triggering job that was scheduled for this step can trigger the step and not any other.
     # @return [void]
-    def perform_next_step!
+    def perform_next_step!(idempotency_key: nil)
       # Make sure we can't start running the same step of the same journey twice
       next_step_name_before_locking = next_step_name
       with_lock do
         # Make sure no other worker has snatched this journey and made steps instead of us
         return unless ready? && next_step_name == next_step_name_before_locking
+        # Check idempotency key if both are present
+        return if idempotency_key && idempotency_key != self.idempotency_key
+
         performing!
         after_locking_for_step(next_step_name)
       end
@@ -205,8 +194,13 @@ module StepperMotor
       increment!(:steps_entered)
       logger.debug { "entering step #{current_step_name}" }
 
-      catch(:abort_step) do
-        instance_exec(&@current_step_definition)
+      # The flow control for reattempt! and cancel! happens inside perform_in_context_of
+      ex_rescued_at_perform = nil
+      begin
+        @current_step_definition.perform_in_context_of(self)
+      rescue => e
+        ex_rescued_at_perform = e
+        logger.debug { "#{e} raised during #{@current_step_definition.name}, will be re-raised after" }
       end
 
       # By the end of the step the Journey must either be untouched or saved
@@ -220,17 +214,20 @@ module StepperMotor
         MSG
       end
 
-      increment!(:steps_completed)
-      logger.debug { "completed #{current_step_name} without exceptions" }
+      if ex_rescued_at_perform
+        logger.warn { "performed #{current_step_name}, #{ex_rescued_at_perform} was raised" }
+      else
+        increment!(:steps_completed)
+        logger.debug { "performed #{current_step_name} without exceptions" }
+      end
 
-      if canceled?
-        # The step aborted the journey, nothing to do
-        logger.info { "has been canceled inside #{current_step_name}" }
+      if paused? || canceled?
+        # The step made arrangements regarding how we shoudl continue, nothing to do
+        logger.info { "has been #{state} inside #{current_step_name}" }
       elsif @reattempt_after
         # The step asked the actions to be attempted at a later time
         logger.info { "will reattempt #{current_step_name} in #{@reattempt_after} seconds" }
-        update!(previous_step_name: current_step_name, next_step_name: current_step_name, next_step_to_be_performed_at: Time.current + @reattempt_after)
-        schedule!
+        set_next_step_and_enqueue(@current_step_definition, wait: @reattempt_after)
         ready!
       elsif finished?
         logger.info { "was marked finished inside the step" }
@@ -240,18 +237,24 @@ module StepperMotor
         set_next_step_and_enqueue(next_step_definition)
         ready!
       else
-        # The hero's journey is complete
-        logger.info { "journey completed" }
+        logger.info { "has finished" } # The hero's journey is complete
         finished!
         update!(previous_step_name: current_step_name, next_step_name: nil)
       end
     ensure
       # The instance variables must not be present if `perform_next_step!` gets called
       # on this same object again. This will be the case if the steps are performed inline
-      # and not via background jobs (which reload the model)
+      # and not via background jobs (which reload the model). This should actually be solved
+      # using some object that contains the state of the action later, but for now - the dirty approach is fine.
       @reattempt_after = nil
       @current_step_definition = nil
-      after_step_completes(current_step_name) if current_step_name
+      # Re-raise the exception, now that we have persisted the Journey according to the recovery policy
+      if ex_rescued_at_perform
+        after_performing_step_with_exception(current_step_name, ex_rescued_at_perform) if current_step_name
+        raise ex_rescued_at_perform
+      elsif current_step_name
+        after_performing_step_without_exception(current_step_name)
+      end
     end
 
     # @return [ActiveSupport::Duration]
@@ -262,9 +265,10 @@ module StepperMotor
       seconds_remaining.seconds # Convert to ActiveSupport::Duration
     end
 
-    def set_next_step_and_enqueue(next_step_definition)
-      wait = next_step_definition.wait
-      update!(previous_step_name: next_step_name, next_step_name: next_step_definition.name, next_step_to_be_performed_at: Time.current + wait)
+    def set_next_step_and_enqueue(next_step_definition, wait: nil)
+      wait ||= next_step_definition.wait
+      next_idempotency_key = SecureRandom.base36(16)
+      update!(previous_step_name: next_step_name, next_step_name: next_step_definition.name, next_step_to_be_performed_at: Time.current + wait, idempotency_key: next_idempotency_key)
       schedule!
     end
 
@@ -282,20 +286,17 @@ module StepperMotor
     def after_locking_for_step(step_name)
     end
 
+    def after_performing_step_with_exception(step_name, exception)
+    end
+
     def before_step_starts(step_name)
     end
 
-    def after_step_completes(step_name)
+    def after_performing_step_without_exception(step_name)
     end
 
     def schedule!
       StepperMotor.scheduler.schedule(self)
     end
-
-    def to_global_id
-      # This gets included into ActiveModel during Rails bootstrap,
-      # for now do this manually
-      GlobalID.create(self, app: "stepper-motor")
-    end
   end
 end

data/lib/stepper_motor/perform_step_job_v2.rb

@@ -3,9 +3,9 @@
 require "active_job"
 
 class StepperMotor::PerformStepJobV2 < ActiveJob::Base
-  def perform(journey_id:, journey_class_name:, **)
+  def perform(journey_id:, journey_class_name:, idempotency_key: nil, **)
     journey = StepperMotor::Journey.find(journey_id)
-    journey.perform_next_step!
+    journey.perform_next_step!(idempotency_key: idempotency_key)
   rescue ActiveRecord::RecordNotFound
     # The journey has been canceled and destroyed previously or elsewhere
   end

data/lib/stepper_motor/recover_stuck_journeys_job_v1.rb

@@ -7,7 +7,9 @@ require "active_job"
 # any journey that stayed in `performing` for longer than 1 hour has hung. Add this job to your
 # cron table and perform it regularly.
 class StepperMotor::RecoverStuckJourneysJobV1 < ActiveJob::Base
-  def perform(stuck_for: 2.days)
+  DEFAULT_STUCK_FOR = 2.days
+
+  def perform(stuck_for: DEFAULT_STUCK_FOR)
     StepperMotor::Journey.stuck(stuck_for.ago).find_each do |journey|
       journey.recover!
     rescue => e

data/lib/stepper_motor/step.rb

@@ -4,16 +4,81 @@
 # array of the Journey subclass. When the step gets performed, the block passed to the
 # constructor will be instance_exec'd with the Journey model being the context
 class StepperMotor::Step
-  attr_reader :name, :wait, :seq
-  def initialize(name:, seq:, wait: 0, &step_block)
+  class MissingDefinition < NoMethodError
+  end
+
+  # @return [String] the name of the step or method to call on the Journey
+  attr_reader :name
+
+  # @return [Numeric,ActiveSupport::Duration] how long to wait before performing the step
+  attr_reader :wait
+
+  # @private
+  attr_reader :seq
+
+  # Creates a new step definition
+  #
+  # @param name[String,Symbol] the name of the Step
+  # @param wait[Numeric,ActiveSupport::Duration] the amount of time to wait before entering the step
+  # @param on_exception[Symbol] the action to take if an exception occurs when performing the step.
+  #   The possible values are:
+  #   * `:cancel!` - cancels the Journey and re-raises the exception. The Journey will be persisted before re-raising.
+  #   * `:reattempt!` - reattempts the Journey and re-raises the exception. The Journey will be persisted before re-raising.
+  def initialize(name:, seq:, on_exception:, wait: 0, &step_block)
     @step_block = step_block
     @name = name.to_s
     @wait = wait
     @seq = seq
+    @on_exception = on_exception # TODO: Validate?
   end
 
-  # Makes the Step object itself callable
-  def to_proc
-    @step_block
+  # Performs the step on the passed Journey, wrapping the step with the required context.
+  #
+  # @param journey[StepperMotor::Journey] the journey to perform the step in. If a `step_block`
+  #   is passed in, it is going to be executed in the context of the journey using `instance_exec`.
+  #   If only the name of the step has been provided, an accordingly named public method on the
+  #   journey will be called
+  # @return void
+  def perform_in_context_of(journey)
+    # This is a tricky bit.
+    #
+    # reattempt!, cancel! (and potentially - future flow control methods) all use `throw` to
+    # immediately hop out of the perform block. They all use the same symbol thrown - :abort_step.
+    # Nothing after `reattempt!` and `cancel!` in the same scope will run because of that `throw` -
+    # not even the `rescue` clauses, so we need to catch here instead of the `perform_next_step!`
+    # method. This way, if the step raises an exception, we can still let Journey flow control methods
+    # be used, but we can capture the exception. Moreover: we need to be able to _call_ those methods from
+    # within the rescue() clauses. So:
+    catch(:abort_step) do
+      if @step_block
+        journey.instance_exec(&@step_block)
+      elsif journey.respond_to?(name)
+        journey.public_send(name) # TODO: context/params?
+      else
+        raise MissingDefinition.new(<<~MSG, name, _args = nil, _private = false, receiver: journey)
+          No block or method to use for step `#{name}' on #{journey.class}
+        MSG
+      end
+    end
+  rescue MissingDefinition
+    # This journey won't succeed with any number of reattempts, cancel it. Cancellation also will throw.
+    catch(:abort_step) { journey.pause! }
+    raise
+  rescue => e
+    # Act according to the set policy. The basic 2 for the moment are :reattempt! and :cancel!,
+    # and can be applied by just calling the methods on the passed journey
+    case @on_exception
+    when :reattempt!
+      catch(:abort_step) { journey.reattempt! }
+    when :cancel!
+      catch(:abort_step) { journey.cancel! }
+    when :pause!
+      catch(:abort_step) { journey.pause! }
+    else
+      # Leave the journey hanging in the "performing" state
+    end
+
+    # Re-raise the exception so that the Rails error handling can register it
+    raise e
   end
 end

data/lib/stepper_motor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StepperMotor
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

data/lib/stepper_motor.rb

@@ -21,6 +21,5 @@ module StepperMotor
   autoload :CyclicScheduler, File.dirname(__FILE__) + "/stepper_motor/cyclic_scheduler.rb"
   autoload :TestHelper, File.dirname(__FILE__) + "/stepper_motor/test_helper.rb"
 
-
   mattr_accessor :scheduler, default: ForwardScheduler.new
 end

data/lib/tasks/stepper_motor_tasks.rake

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+namespace :stepper_motor do
+  desc "Recover all journeys hanging in the 'performing' state"
+  task :recovery do
+    StepperMotor::RecoverStuckJourneysJobV1.perform_now
+  end
+end