dalliance 0.6.0 → 0.9.0

data/lib/dalliance.rb

@@ -91,6 +91,8 @@ module Dalliance
     scope :validation_error, -> { where(:dalliance_status => 'validation_error') }
     scope :processing_error, -> { where(:dalliance_status => 'processing_error') }
     scope :completed, -> { where(:dalliance_status => 'completed') }
+    scope :cancel_requested, -> { where(:dalliance_status => 'cancel_requested') }
+    scope :cancelled, -> { where(:dalliance_status => 'cancelled') }
 
     state_machine :dalliance_status, :initial => :pending do
       state :pending
@@ -98,6 +100,8 @@ module Dalliance
       state :validation_error
       state :processing_error
       state :completed
+      state :cancel_requested
+      state :cancelled
 
       #event :queue_dalliance do
       #  transition :processing_error => :pending
@@ -116,7 +120,22 @@ module Dalliance
       end
 
       event :finish_dalliance do
-        transition :processing => :completed
+        transition [:processing, :cancel_requested] => :completed
+      end
+
+      event :reprocess_dalliance do
+        transition [:validation_error, :processing_error, :completed] => :pending
+      end
+
+      # Requests the record to stop processing. This does NOT cause processing
+      # to stop!  Each model is required to handle cancellation on its own by
+      # periodically checking the dalliance status
+      event :request_cancel_dalliance do
+        transition [:pending, :processing] => :cancel_requested
+      end
+
+      event :cancelled_dalliance do
+        transition [:cancel_requested] => :cancelled
       end
     end
     #END state_machine(s)
@@ -175,7 +194,9 @@ module Dalliance
         else
           self.class.where(id: self.id).update_all(dalliance_status: dalliance_status, dalliance_error_hash: dalliance_error_hash.to_yaml )
         end
+      # rubocop:disable Lint/SuppressedException
       rescue
+      # rubocop:enable Lint/SuppressedException
       end
     end
   end
@@ -185,13 +206,35 @@ module Dalliance
   end
 
   def error_or_completed?
-    validation_error? || processing_error? || completed?
+    validation_error? || processing_error? || completed? || cancelled?
+  end
+
+  # Cancels the job and removes it from the queue if has not already been taken
+  # by a worker.  If the job is processing, it is up to the job implementation
+  # to stop and do any necessary cleanup.  If the job does not honor the
+  # cancellation request, it will finish processing as normal and finish with a
+  # dalliance_status of 'completed'.
+  #
+  # Jobs can currently only be removed from Resque queues.  DelayedJob jobs will
+  # not be dequeued, but will immediately exit once taken by a worker.
+  def cancel_and_dequeue_dalliance!
+    should_dequeue = pending?
+
+    request_cancel_dalliance!
+
+    if should_dequeue
+      self.dalliance_options[:worker_class].dequeue(self)
+      dalliance_log("[dalliance] #{self.class.name}(#{id}) - #{dalliance_status} - Removed from #{processing_queue} queue")
+      cancelled_dalliance!
+    end
+
+    true
   end
 
   def validate_dalliance_status
     unless error_or_completed?
-      errors.add(:dalliance_status, :invalid)
-      if defined?(Rails) && ::Rails::VERSION::MAJOR == 5 && ::Rails::VERSION::MINOR >= 0
+      errors.add(:dalliance_status, "Processing must be finished or cancelled, but status is '#{dalliance_status}'")
+      if defined?(Rails)
         throw(:abort)
       else
         return false
@@ -213,17 +256,46 @@ module Dalliance
     end
   end
 
-  #Force backgound_processing w/ true
-  def dalliance_background_process(backgound_processing = nil)
-    if backgound_processing || (backgound_processing.nil? && self.class.dalliance_options[:background_processing])
-      self.class.dalliance_options[:worker_class].enqueue(self, processing_queue)
+  #Force background_processing w/ true
+  def dalliance_background_process(background_processing = nil)
+    if background_processing || (background_processing.nil? && self.class.dalliance_options[:background_processing])
+      self.class.dalliance_options[:worker_class].enqueue(self, processing_queue, :dalliance_process)
     else
       dalliance_process(false)
     end
   end
 
-  #backgound_processing == false will re-raise any exceptions
-  def dalliance_process(backgound_processing = false)
+  def dalliance_process(background_processing = false)
+    do_dalliance_process(
+      perform_method: self.class.dalliance_options[:dalliance_method],
+      background_processing: background_processing
+    )
+  end
+
+  def dalliance_background_reprocess(background_processing = nil)
+    # Reset state to 'pending' before queueing up
+    # Otherwise the model will stay on completed/processing_error until the job
+    # is taken by a worker, which could be a long time after this method is
+    # called.
+    reprocess_dalliance!
+    if background_processing || (background_processing.nil? && self.class.dalliance_options[:background_processing])
+      self.class.dalliance_options[:worker_class].enqueue(self, processing_queue, :do_dalliance_reprocess)
+    else
+      do_dalliance_reprocess(false)
+    end
+  end
+
+  def dalliance_reprocess(background_processing = false)
+    reprocess_dalliance!
+    do_dalliance_reprocess(background_processing)
+  end
+
+  def do_dalliance_process(perform_method:, background_processing: false)
+    # The job might have been cancelled after it was queued, but before
+    # processing started.  Check for that up front before doing any processing.
+    cancelled_dalliance! if cancel_requested?
+    return if cancelled? # method generated from AASM
+
     start_time = Time.now
 
     begin
@@ -233,9 +305,9 @@ module Dalliance
         build_dalliance_progress_meter(:total_count => calculate_dalliance_progress_meter_total_count).save!
       end
 
-      self.send(self.class.dalliance_options[:dalliance_method])
+      self.send(perform_method)
 
-      finish_dalliance! unless validation_error?
+      finish_dalliance! unless validation_error? || cancelled?
     rescue StandardError => e
       #Save the error for future analysis...
       self.dalliance_error_hash = {:error => e.class.name, :message => e.message, :backtrace => e.backtrace}
@@ -255,14 +327,16 @@ module Dalliance
           else
             self.class.where(id: self.id).update_all(dalliance_status: dalliance_status, dalliance_error_hash: dalliance_error_hash.to_yaml )
           end
+        # rubocop:disable Lint/SuppressedException
         rescue
+        # rubocop:enable Lint/SuppressedException
         end
       end
 
       error_notifier.call(e)
 
-      #Don't raise the error if we're backgound_processing...
-      raise e unless backgound_processing && self.class.dalliance_options[:worker_class].rescue_error?
+      # Don't raise the error if we're background processing...
+      raise e unless background_processing && self.class.dalliance_options[:worker_class].rescue_error?
     ensure
       if self.class.dalliance_options[:dalliance_progress_meter] && dalliance_progress_meter
         #Works with optimistic locking...
@@ -274,8 +348,11 @@ module Dalliance
 
       dalliance_log("[dalliance] #{self.class.name}(#{id}) - #{dalliance_status} #{duration.to_i}")
 
-      if self.class.dalliance_options[:duration_column]
-        self.class.where(id: self.id).update_all(self.class.dalliance_options[:duration_column] => duration.to_i)
+      duration_column = self.class.dalliance_options[:duration_column]
+      if duration_column.present?
+        current_duration = self.send(duration_column) || 0
+        self.class.where(id: self.id)
+          .update_all(duration_column => current_duration + duration.to_f)
       end
     end
   end
@@ -305,6 +382,19 @@ module Dalliance
     end
   end
 
+  private
+
+  # Executes the reprocessing method defined in the model's dalliance options.
+  #
+  # @param [Boolean] background_processing
+  #   flag if this is called from a background worker. Defaults to false.
+  def do_dalliance_reprocess(background_processing = false)
+    do_dalliance_process(
+      perform_method: self.class.dalliance_options[:reprocess_method],
+      background_processing: background_processing
+    )
+  end
+
   module Glue
     extend ActiveSupport::Concern
 
@@ -313,15 +403,28 @@ module Dalliance
     end
 
     module ClassMethods
-      def dalliance(*args)
-        options = args.last.is_a?(Hash) ? Dalliance.options.merge(args.pop) : Dalliance.options
-
-        case args.length
-        when 1
-          options[:dalliance_method] = args[0]
-        else
-          raise ArgumentError, "Incorrect number of Arguements provided"
-        end
+      # Enables dalliance processing for this class.
+      #
+      # @param [Symbol|String] dalliance_method
+      #   the name of the method to call when processing the model in dalliance
+      # @param [Hash] options
+      #   an optional hash of options for dalliance processing
+      # @option options [Symbol] :reprocess_method
+      #   the name of the method to use to reprocess the model in dalliance
+      # @option options [Boolean] :dalliance_process_meter
+      #   whether or not to display a progress meter
+      # @option options [String] :queue
+      #   the name of the worker queue to use. Default 'dalliance'
+      # @option options [String] :duration_column
+      #   the name of the table column that stores the dalliance processing time. Default 'dalliance_duration'
+      # @option options [Object] :logger
+      #   the logger object to use. Can be nil
+      # @option options [Proc] :error_notifier
+      #   A proc that accepts an error object. Default is a NOP
+      def dalliance(dalliance_method, options = {})
+        opts = Dalliance.options.merge(options)
+
+        opts[:dalliance_method] = dalliance_method
 
         if dalliance_options.nil?
           self.dalliance_options = {}
@@ -329,7 +432,7 @@ module Dalliance
           self.dalliance_options = self.dalliance_options.dup
         end
 
-        self.dalliance_options.merge!(options)
+        self.dalliance_options.merge!(opts)
 
         include Dalliance
       end

data/lib/dalliance/engine.rb

@@ -7,7 +7,7 @@ module Dalliance
       ActiveSupport.on_load :active_record do
         include Dalliance::Glue
 
-        ActiveRecord::ConnectionAdapters::TableDefinition.send(:include, Dalliance::Schema)
+        ActiveRecord::ConnectionAdapters::TableDefinition.include Dalliance::Schema
       end
     end
   end

data/lib/dalliance/progress_meter.rb

@@ -46,20 +46,20 @@ module Dalliance
     #TODO: This is just a stopgap until I fix increment! to be thread-safe
     def progress
       begin
-        _progress = (current_count.to_f / total_count.to_f * 100).to_i
+        current_progress = (current_count.to_f / total_count.to_f * 100).to_i
 
         #Handle an incorrect total_count...
-        _progress = 100 if _progress > 100
+        current_progress = 100 if current_progress > 100
       rescue
         #what, are you diving by zero?
-        _progress = 0
+        current_progress = 0
       end
 
-      _progress
+      current_progress
     end
 
     def increment!
       Dalliance::ProgressMeter.increment_counter(:current_count, self.id)
     end
   end
-end
+end

data/lib/dalliance/version.rb

@@ -1,7 +1,7 @@
 module Dalliance
   module VERSION
     MAJOR = 0
-    MINOR = 6
+    MINOR = 9
     TINY  = 0
     PRE   = nil
 

data/lib/dalliance/workers/delayed_job.rb

@@ -1,15 +1,24 @@
 module Dalliance
   module Workers
-    if defined?(Rails) && ((::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR >= 2) || ::Rails::VERSION::MAJOR >= 5)
+    if defined?(Rails)
       class DelayedJob < ::ActiveJob::Base
         queue_as :dalliance
 
-        def self.enqueue(instance, queue = 'dalliance')
-          Dalliance::Workers::DelayedJob.set(queue: queue).perform_later(instance.class.name, instance.id)
+        def self.enqueue(instance, queue = 'dalliance', perform_method)
+          Dalliance::Workers::DelayedJob
+            .set(queue: queue)
+            .perform_later(instance.class.name, instance.id, perform_method.to_s)
         end
 
-        def perform(instance_klass, instance_id)
-          instance_klass.constantize.find(instance_id).dalliance_process(true)
+        def self.dequeue(_instance)
+          # NOP
+        end
+
+        def perform(instance_klass, instance_id, perform_method)
+          instance_klass
+            .constantize
+            .find(instance_id)
+            .send(perform_method, true)
         end
 
         #Delayed job automatically retries, so rescue the error
@@ -18,13 +27,23 @@ module Dalliance
         end
       end
     else
-      class DelayedJob < Struct.new(:instance_klass, :instance_id)
-        def self.enqueue(instance, queue = 'dalliance')
-          ::Delayed::Job.enqueue(self.new(instance.class.name, instance.id), :queue => queue)
+      class DelayedJob < Struct.new(:instance_klass, :instance_id, :perform_method)
+        def self.enqueue(instance, queue = 'dalliance', perform_method)
+          ::Delayed::Job.enqueue(
+            self.new(instance.class.name, instance.id, perform_method),
+            :queue => queue
+          )
+        end
+
+        def self.dequeue(_instance)
+          # NOP
         end
 
         def perform
-          instance_klass.constantize.find(instance_id).dalliance_process(true)
+          instance_klass
+            .constantize
+            .find(instance_id)
+            .send(perform_method, true)
         end
 
         #Delayed job automatically retries, so rescue the error

data/lib/dalliance/workers/resque.rb

@@ -1,15 +1,37 @@
 module Dalliance
   module Workers
-    if defined?(Rails) && ((::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR >= 2) || ::Rails::VERSION::MAJOR >= 5)
+    if defined?(Rails)
       class Resque < ::ActiveJob::Base
         queue_as :dalliance
 
-        def self.enqueue(instance, queue = 'dalliance')
-          Dalliance::Workers::Resque.set(queue: queue).perform_later(instance.class.name, instance.id)
+        def self.enqueue(instance, queue = 'dalliance', perform_method)
+          Dalliance::Workers::Resque
+            .set(queue: queue)
+            .perform_later(instance.class.name, instance.id, perform_method.to_s)
         end
 
-        def perform(instance_klass, instance_id)
-          instance_klass.constantize.find(instance_id).dalliance_process(true)
+        def self.dequeue(instance)
+          redis = ::Resque.redis
+          queue = instance.processing_queue
+
+          redis.everything_in_queue(queue).each do |string|
+            # Structure looks like, e.g.
+            # { 'class' => 'ActiveJob::...', 'args' => [{ 'arguments' => ['SomeClass', 123, 'dalliance_process'] }] }
+            data = ::Resque.decode(string)
+            dalliance_args = data['args'][0]['arguments']
+
+            if dalliance_args == [instance.class.name, instance.id, 'dalliance_process'] ||
+               dalliance_args == [instance.class.name, instance.id, 'dalliance_reprocess']
+              redis.remove_from_queue(queue, string)
+            end
+          end
+        end
+
+        def perform(instance_klass, instance_id, perform_method)
+          instance_klass
+            .constantize
+            .find(instance_id)
+            .send(perform_method, true)
         end
 
         #Resque fails, so don't rescue the error
@@ -19,12 +41,32 @@ module Dalliance
       end
     else
       class Resque
-        def self.enqueue(instance, queue = 'dalliance')
-          ::Resque.enqueue_to(queue, self, instance.class.name, instance.id)
+        def self.enqueue(instance, queue = 'dalliance', perform_method)
+          ::Resque.enqueue_to(queue, self, instance.class.name, instance.id, perform_method.to_s)
+        end
+
+        def self.dequeue(instance)
+          redis = ::Resque.redis
+          queue = instance.processing_queue
+
+          redis.everything_in_queue(queue).each do |string|
+            # Structure looks like, e.g.
+            # { 'class' => 'ActiveJob::...', 'args' => [{ 'arguments' => ['SomeClass', 123, 'dalliance_process'] }] }
+            data = ::Resque.decode(string)
+            dalliance_args = data['args'][0]['arguments']
+
+            if dalliance_args == [instance.class.name, instance.id, 'dalliance_process'] ||
+               dalliance_args == [instance.class.name, instance.id, 'dalliance_reprocess']
+              redis.remove_from_queue(queue, string)
+            end
+          end
         end
 
-        def self.perform(instance_klass, instance_id)
-          instance_klass.constantize.find(instance_id).dalliance_process(true)
+        def self.perform(instance_klass, instance_id, perform_method)
+          instance_klass
+            .constantize
+            .find(instance_id)
+            .send(perform_method, true)
         end
 
         #Resque fails, so don't rescue the error

data/spec/dalliance/asynchronous_delayed_job_spec.rb

@@ -77,6 +77,48 @@ RSpec.describe DallianceModel do
       expect(subject.dalliance_duration).not_to eq(nil)
     end
 
+    context 'reprocess' do
+      before(:all) do
+        DallianceModel.dalliance_options[:dalliance_method] = :dalliance_success_method
+        DallianceModel.dalliance_options[:worker_class] = Dalliance::Workers::DelayedJob
+        DallianceModel.dalliance_options[:queue] = 'dalliance'
+      end
+
+      before do
+        subject.dalliance_process
+        subject.reload
+      end
+
+      it 'successfully runs the dalliance_reprocess method' do
+        subject.dalliance_background_reprocess
+        Delayed::Worker.new(:queues => [:dalliance]).work_off
+        subject.reload
+
+        expect(subject).to be_successful
+        expect(Delayed::Job.count).to eq(0)
+        expect(subject.reprocessed_count).to eq(1)
+      end
+
+      it 'increases the total processing time counter' do
+        original_duration = subject.dalliance_duration
+        subject.dalliance_background_reprocess
+        Delayed::Worker.new(:queues => [:dalliance]).work_off
+        subject.reload
+
+        expect(subject.dalliance_duration).to be_between(original_duration, Float::INFINITY)
+      end
+
+      it "resets the dalliance_status to 'pending'" do
+        subject.update_column(:dalliance_status, 'processing_error')
+        expect { subject.dalliance_background_reprocess }
+          .to change(subject, :dalliance_status)
+          .to('pending')
+
+        Delayed::Worker.new(:queues => [:dalliance]).work_off
+        expect(subject).to be_successful
+      end
+    end
+
     context "another_queue" do
       let(:queue) { 'dalliance_2'}