resque-approve 0.0.4 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e8ca59f3ecba62eae0dc3399c1ca5f82df1fe7d9
-  data.tar.gz: 062fa0951dd4bbe28b25663561c507806a23288f
+SHA256:
+  metadata.gz: 4964a615615665834296d65c85866378409435eb0eba93bc5932978334d7ac3b
+  data.tar.gz: 900f8341e08a2da8fa893016a8f36c4f8bd47996c6848a314ba47586df8cb47a
 SHA512:
-  metadata.gz: b6cf2c253fd889aa77e5d0a21a40e5b4235020221282d43fe31233695fc50d78b149d65b89f7be10de74bbbcc31e04f55e708432faf2dcac62ae870f32fea197
-  data.tar.gz: 721007d47b2b5bc52434b2cbdf65eaae21df7043f2d7e2dc2f831f6677b5f827bded14b663f3d93757b395fedafff28b9080c1d1f8590c8fb7ff697b07cb1077
+  metadata.gz: '0942156347f37b046f148de6e941a7c6ffa2fada7659201f56889f04cf0bcf3ddbb03d3e469aa07c2fbb6f27f0486cee2aebb4d9b91d86ecc349c8ee7686ba74'
+  data.tar.gz: 53575d650f15b4c51477e85b321c420edf783fbc6a45380a47b91149a11b365ce068b33098435c0c73b25464bd770dd784e606dece377c718daaced99ff0bada

data/lib/resque-approve.rb

@@ -6,5 +6,6 @@ require File.expand_path(File.join("resque", "plugins", "approve", "pending_job"
 require File.expand_path(File.join("resque", "plugins", "approve", "pending_job_queue"), File.dirname(__FILE__))
 require File.expand_path(File.join("resque", "plugins", "approve", "approval_key_list"), File.dirname(__FILE__))
 require File.expand_path(File.join("resque", "plugins", "approve", "cleaner"), File.dirname(__FILE__))
+require File.expand_path(File.join("resque", "plugins", "approve", "auto_approve_next"), File.dirname(__FILE__))
 
 require File.expand_path(File.join("resque", "plugins", "approve"), File.dirname(__FILE__))

data/lib/resque/approve_server.rb

@@ -95,7 +95,7 @@ module Resque
 
       def add_static_files(base)
         base.class_eval do
-          get %r{approve/public/([a-z_]+\.[a-z]+)} do
+          get %r{/approve/public/([a-z_]+\.[a-z]+)} do
             send_file Resque::ApproveServer.public_path(params[:captures]&.first)
           end
         end
@@ -107,6 +107,7 @@ module Resque
         delete_all_queues(base)
         approve_all_queues(base)
         delete_queue(base)
+        reset_running(base)
         delete_one_queue(base)
         approve_queue(base)
         approve_one_queue(base)
@@ -167,6 +168,16 @@ module Resque
         end
       end
 
+      def reset_running(base)
+        base.class_eval do
+          post "/approve/reset_running" do
+            Resque::Plugins::Approve::PendingJobQueue.new(params[:approval_key]).reset_running
+
+            redirect u("approve/job_list?#{{ approval_key: params[:approval_key] }.to_param}")
+          end
+        end
+      end
+
       def delete_one_queue(base)
         base.class_eval do
           post "/approve/delete_one_queue" do

data/lib/resque/plugins/approve.rb

@@ -11,6 +11,8 @@ module Resque
 
       included do
         self.auto_delete_approval_key = false
+        self.max_active_jobs          = -1
+        self.default_queue_name       = nil
       end
 
       class << self
@@ -46,20 +48,60 @@ module Resque
           @auto_delete_approval_key
         end
 
+        def max_active_jobs=(value)
+          @max_active_jobs = value
+        end
+
+        def max_active_jobs
+          @max_active_jobs
+        end
+
+        def default_queue_name=(value)
+          @default_queue_name = value
+        end
+
+        def default_queue_name
+          @default_queue_name || Resque.queue_from_class(self)
+        end
+
+        def approve
+          Resque::Plugins::Approve.approve(default_queue_name)
+        end
+
+        def approve_one
+          Resque::Plugins::Approve.approve_one(default_queue_name)
+        end
+
+        def approve_num(num_approve)
+          Resque::Plugins::Approve.approve_num(num_approve, default_queue_name)
+        end
+
+        def remove
+          Resque::Plugins::Approve.remove(default_queue_name)
+        end
+
+        def remove_one
+          Resque::Plugins::Approve.remove_one(default_queue_name)
+        end
+
         # It is possible to run a job immediately using `Resque.push`.  This will bypass the queue and run
         # the job immediately.  This will prevent such a job from enqueuing, and instead pause it for approval
         #
         # The primary reason for this is to prevent the job from receiving the approval parameters it is not
         # supposed to have when actually run/enqueued.
+        #
+        # NOTE:  This does not validate running counts.
         def before_perform_approve(*args)
           # Check if the job needs to be approved, and if so, do not enqueue it.
           job = PendingJob.new(SecureRandom.uuid, class_name: name, args: args)
 
-          if job.requires_approval?
+          if job.approval_keys? && !job.max_active_jobs?
             ApprovalKeyList.new.add_job(job)
 
             raise Resque::Job::DontPerform, "The job has not been approved yet."
           else
+            job.max_jobs_perform_args(args)
+
             true
           end
         end
@@ -72,6 +114,8 @@ module Resque
             ApprovalKeyList.new.add_job(job)
             false
           else
+            job.max_jobs_perform_args(args)
+
             true
           end
         end

data/lib/resque/plugins/approve/approval_key_list.rb

@@ -20,7 +20,7 @@ module Resque
         end
 
         def remove_key(key)
-          Resque::Plugins::Approve::PendingJobQueue.new(job.approval_key).resume
+          Resque::Plugins::Approve::PendingJobQueue.new(key).resume
 
           redis.srem(list_key, key)
         end

data/lib/resque/plugins/approve/auto_approve_next.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Resque
+  module Plugins
+    module Approve
+      # This module adds a new class level perform method that overrides the jobs classes
+      # class method perform that is used by Resque.
+      #
+      # The new overloaded method uses super to perform the original perform functionality
+      # but ensures that when the job is complete that it approves the next job in the queue.
+      #
+      # The reason for this class is to manage the maximum number of jobs that are allowed to
+      # run at the same time for a particular job.  When the maximum number of jobs is reached
+      # when a job completes, it will approve the next job in the queue automatically.
+      module AutoApproveNext
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def perform(*args)
+            job          = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid, class_name: name, args: args)
+            dup_args     = job.args
+            del_options  = dup_args.extract_options!.with_indifferent_access
+            approval_key = del_options.delete(:approval_key) || job.approve_options[:approval_key]
+
+            dup_args << del_options if del_options.present?
+
+            begin
+              super(*dup_args)
+            ensure
+              Resque::Plugins::Approve::PendingJobQueue.new(approval_key).decrement_running
+              Resque::Plugins::Approve.approve_one approval_key
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resque/plugins/approve/pending_job.rb

@@ -12,31 +12,35 @@ module Resque
       #   class_name  - The name of the job class to be enqueued
       #   args        - The arguments for the job to be enqueued
       #
-      #   approval_key    - The approval key for the pending job that will be used to release/approve the job.
-      #                     This will default to nil.
-      #   approval_queue  - The queue that the pending job will be enqueued into.
-      #                     This will default to the queue for the job.
-      #   approval_at     - The time when the job is to be enqueued.
-      #                     This will call `enqueue_at` to enqueue the job, so this option will only work
-      #                     properly if you use the `resque-scheduler` gem.
+      #   requires_approval - If a class defines a default approval queue (similar to defining
+      #                       the queue for Resque), then instead of passing `approval_key: "key name"` in the
+      #                       parameters, you would pass `requires_approval: true`.  This way the key name
+      #                       appears only in the class and not scattered through the code.
+      #   approval_key      - The approval key for the pending job that will be used to release/approve the job.
+      #                       This will default to nil.
+      #   approval_queue    - The queue that the pending job will be enqueued into.
+      #                       This will default to the queue for the job.
+      #   approval_at       - The time when the job is to be enqueued.
+      #                       This will call `enqueue_at` to enqueue the job, so this option will only work
+      #                       properly if you use the `resque-scheduler` gem.
       #
-      #                     When using resque-scheduler, there are two ways to delay enqueue a job
-      #                     and how you do this depends on your use case.
+      #                       When using resque-scheduler, there are two ways to delay enqueue a job
+      #                       and how you do this depends on your use case.
       #
-      #                     Resque.enqueue YourJob, params, approval_key: "your key", approval_at: time
-      #                     This will enqueue the job for approval, which will pause the job until it is approved.
-      #                     Once approved, the job will delay enqueue for time, and will execute immediately or at
-      #                     that time depending on if the time has passed.
+      #                       Resque.enqueue YourJob, params, approval_key: "your key", approval_at: time
+      #                       This will enqueue the job for approval, which will pause the job until it is approved.
+      #                       Once approved, the job will delay enqueue for time, and will execute immediately or at
+      #                       that time depending on if the time has passed.
       #
-      #                     This is the recommended method to use as it will not run the job early, and it will allow
-      #                     you to release it without knowing if it is still delayed or not.
+      #                       This is the recommended method to use as it will not run the job early, and it will allow
+      #                       you to release it without knowing if it is still delayed or not.
       #
-      #                     You can also do:
-      #                     Resque.enqueue_at time, YourJob, params, approval_key: "your key"
-      #                     This will delay enqueue the job - because it has not been enqueued yet, the job
-      #                     cannot be releaed until the time has passed and the job is actually enqueued.
-      #                     Any time after that point, it can be released.  Releasing the key before this
-      #                     time has no effect on this job.
+      #                       You can also do:
+      #                       Resque.enqueue_at time, YourJob, params, approval_key: "your key"
+      #                       This will delay enqueue the job - because it has not been enqueued yet, the job
+      #                       cannot be releaed until the time has passed and the job is actually enqueued.
+      #                       Any time after that point, it can be released.  Releasing the key before this
+      #                       time has no effect on this job.
       class PendingJob
         include Resque::Plugins::Approve::RedisAccess
         include Comparable
@@ -86,8 +90,12 @@ module Resque
                              end
         end
 
+        def approval_keys?
+          @approval_keys ||= (approve_options.key?(:approval_key) || approve_options[:requires_approval])
+        end
+
         def requires_approval?
-          @requires_approval ||= approve_options.key?(:approval_key) || approve_options[:requires_approval]
+          @requires_approval ||= approval_keys? && too_many_running?
         end
 
         def approval_key
@@ -98,6 +106,21 @@ module Resque
           @approval_queue ||= approve_options[:approval_queue] || Resque.queue_from_class(klass)
         end
 
+        def max_active_jobs?
+          return @max_active_jobs if defined?(@max_active_jobs)
+
+          @max_active_jobs = max_active_jobs.positive?
+        end
+
+        def max_active_jobs
+          max_val = ((klass.respond_to?(:max_active_jobs) && klass.max_active_jobs) ||
+              (klass.instance_variable_defined?(:@max_active_jobs) && klass.instance_variable_get(:@max_active_jobs)))
+
+          return -1 if max_val.blank?
+
+          max_val.to_i
+        end
+
         def approval_at
           @approval_at ||= approve_options[:approval_at]&.to_time
         end
@@ -132,10 +155,10 @@ module Resque
           # Make sure the job is loaded into memory so we can use it even though we are going to delete it.
           stored_values
 
-          return if class_name.blank?
-
           redis.del(job_key)
 
+          return if class_name.blank?
+
           queue.remove_job(self)
         end
 
@@ -143,6 +166,16 @@ module Resque
           @queue ||= Resque::Plugins::Approve::PendingJobQueue.new(approval_key)
         end
 
+        def max_jobs_perform_args(args)
+          remove_options = args.extract_options!.with_indifferent_access
+
+          return if remove_options.blank?
+
+          options = remove_options.slice!(:approval_queue, :approval_at, :requires_approval)
+
+          args << options if options.present?
+        end
+
         private
 
         def klass
@@ -158,15 +191,27 @@ module Resque
         end
 
         def extract_approve_options
-          return if args.blank? || !args[-1].is_a?(Hash)
+          return if args.blank? || !@args[-1].is_a?(Hash)
+
+          self.approve_options = @args.pop
+
+          options = slice_approval_options
 
-          self.approve_options = args.pop
+          @args << options.to_hash if options.present?
+        end
+
+        # rubocop:disable Layout/SpaceAroundOperators
+        def slice_approval_options
+          options                        = approve_options.slice!(:approval_key, :approval_queue, :approval_at, :requires_approval)
+          approve_options[:approval_key] ||= klass.default_queue_name if approve_options[:requires_approval]
 
-          options = approve_options.slice!(:approval_key, :approval_queue, :approval_at)
+          options_approval_key(options)
 
-          args << options.to_hash if options.present?
+          options
         end
 
+        # rubocop:enable Layout/SpaceAroundOperators
+
         def encode_args(*args)
           Resque.encode(args)
         end
@@ -180,6 +225,27 @@ module Resque
         def approve_options=(value)
           @approve_options = (value&.dup || {}).with_indifferent_access
         end
+
+        def too_many_running?
+          return true if queue.paused?
+          return true unless max_active_jobs?
+          return @too_many_running if defined?(@too_many_running)
+
+          num_running = queue.increment_running
+          max_jobs    = max_active_jobs
+
+          queue.decrement_running if num_running > max_jobs
+          @too_many_running = num_running > max_jobs
+        end
+
+        def options_approval_key(options)
+          return unless max_active_jobs?
+          return if options.key?(:approval_key)
+
+          klass.include Resque::Plugins::Approve::AutoApproveNext unless klass.included_modules.include?(Resque::Plugins::Approve::AutoApproveNext)
+
+          options[:approval_key] = approve_options.fetch(:approval_key) { klass.default_queue_name }
+        end
       end
       # rubocop:enable Metrics/ClassLength
     end

data/lib/resque/plugins/approve/pending_job_queue.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ClassLength
+
 module Resque
   module Plugins
     module Approve
@@ -15,6 +17,24 @@ module Resque
           @approval_key = approval_key
         end
 
+        def num_running
+          redis.get(running_key)
+        end
+
+        def reset_running
+          redis.set(running_key, 0)
+        end
+
+        def increment_running
+          Resque::Plugins::Approve::ApprovalKeyList.new.add_key approval_key
+          redis.incr(running_key)
+        end
+
+        def decrement_running
+          Resque::Plugins::Approve::ApprovalKeyList.new.add_key approval_key
+          redis.decr(running_key)
+        end
+
         def pause
           redis.set(pause_key, true)
           redis.set(paused_count_key, 0)
@@ -89,6 +109,10 @@ module Resque
           delete_job(id)
         end
 
+        def remove_num(num_approve)
+          num_approve.times { remove_one }
+        end
+
         def remove_all
           true while remove_one
         end
@@ -161,10 +185,16 @@ module Resque
           @pause_key ||= "approve.job_queue.#{approval_key}.paused"
         end
 
+        def running_key
+          @running_key ||= "approve.job_queue.#{approval_key}.running"
+        end
+
         def paused_count_key
-          @pause_key ||= "approve.job_queue.#{approval_key}.paused.count"
+          @paused_count_key ||= "approve.job_queue.#{approval_key}.paused.count"
         end
       end
     end
   end
 end
+
+# rubocop:enable Metrics/ClassLength

data/lib/resque/plugins/version.rb

@@ -3,7 +3,7 @@
 module Resque
   module Plugins
     module Approve
-      VERSION = "0.0.4"
+      VERSION = "0.0.12"
     end
   end
 end

data/lib/resque/server/views/_approval_key_rows.erb

@@ -2,12 +2,15 @@
   <tr>
     <td>
       <a href="<%= u("approve") %>/job_list?<%= { approval_key: pending_job.approval_key }.to_param %>">
-        <%= pending_job.approval_key %>
+        <%= pending_job.approval_key.presence || "&nbsp;&nbsp;&nbsp;".html_safe %>
       </a>
     </td>
     <td>
       <%= pending_job.num_jobs.to_i %>
     </td>
+    <td>
+      <%= pending_job.num_running.to_i %>
+    </td>
     <td>
       <% if pending_job.first_enqueued.present? %>
         <%= time_ago_in_words(pending_job.first_enqueued) %> ago