dalliance 0.5.1 → 0.8.2

data/lib/dalliance.rb

@@ -118,6 +118,10 @@ module Dalliance
       event :finish_dalliance do
         transition :processing => :completed
       end
+
+      event :reprocess_dalliance do
+        transition [:validation_error, :processing_error, :completed] => :pending
+      end
     end
     #END state_machine(s)
 
@@ -175,7 +179,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
@@ -191,7 +197,7 @@ module Dalliance
   def validate_dalliance_status
     unless error_or_completed?
       errors.add(:dalliance_status, :invalid)
-      if defined?(Rails) && ::Rails::VERSION::MAJOR == 5 && ::Rails::VERSION::MINOR >= 0
+      if defined?(Rails)
         throw(:abort)
       else
         return false
@@ -213,17 +219,41 @@ 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)
     start_time = Time.now
 
     begin
@@ -233,7 +263,7 @@ 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?
     rescue StandardError => e
@@ -255,14 +285,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 +306,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 +340,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 +361,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 +390,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,8 +1,8 @@
 module Dalliance
   module VERSION
     MAJOR = 0
-    MINOR = 5
-    TINY  = 1
+    MINOR = 8
+    TINY  = 2
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')

data/lib/dalliance/workers/delayed_job.rb

@@ -1,15 +1,20 @@
 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 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 +23,19 @@ 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 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,20 @@
 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 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 +24,15 @@ 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.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'}
 

data/spec/dalliance/asynchronous_resque_spec.rb

@@ -114,6 +114,60 @@ RSpec.describe DallianceModel do
     end
   end
 
+  context 'reprocess' do
+    before :all do
+      DallianceModel.dalliance_options[:dalliance_method] = :dalliance_success_method
+      DallianceModel.dalliance_options[:worker_class] = Dalliance::Workers::Resque
+      DallianceModel.dalliance_options[:queue] = 'dalliance'
+    end
+
+    before do
+      subject.dalliance_process
+      subject.reload
+    end
+
+    it 'successfully runs the dalliance_reprocess method' do
+      Resque::Stat.clear(:processed)
+      Resque::Stat.clear(:failed)
+
+      subject.dalliance_background_reprocess
+      Resque::Worker.new(:dalliance).process
+      subject.reload
+
+      aggregate_failures do
+        expect(subject).to be_successful
+        expect(Resque.size(:dalliance)).to eq(0)
+        expect(Resque::Stat[:processed]).to eq(1)
+        expect(Resque::Stat[:failed]).to eq(0)
+        expect(subject.reprocessed_count).to eq(1)
+      end
+    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')
+
+      Resque::Stat.clear(:processed)
+      Resque::Stat.clear(:failed)
+
+      expect { subject.dalliance_background_reprocess }
+        .to change(subject, :dalliance_status)
+        .to('pending')
+
+      Resque::Worker.new(:dalliance).process
+
+      expect(subject).to be_successful
+    end
+  end
+
   context "raise error" do
     before(:all) do
       DallianceModel.dalliance_options[:dalliance_method] = :dalliance_error_method

data/spec/dalliance/dalliance_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe 'Dalliance' do
 
   context "human_attribute_name" do
     it "should display the correct locale" do
-      expect(DallianceModel.human_attribute_name(:dalliance_status)).to eq ('Status')
+      expect(DallianceModel.human_attribute_name(:dalliance_status)).to eq('Status')
     end
   end
 
@@ -44,7 +44,7 @@ RSpec.describe 'Dalliance' do
       end
 
       context "w/ args" do
-        let(:queue) { Proc.new{ |a,b,c| 'dalliance_2' } }
+        let(:queue) { Proc.new{ |_a,_b,_c| 'dalliance_2' } }
 
         specify{ expect(subject.processing_queue).to eq(queue.call) }
       end