resque-approve 0.0.7 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 346c8fcef056427d3dd16e9f6c3075d66ba2a209
-  data.tar.gz: 961923c6b5fa71e78763dc9e3b29791ad737cba8
+SHA256:
+  metadata.gz: 016bb046286c17b61fd13b252761500bf002430f1a0690d2cb6c49ec55353136
+  data.tar.gz: 81ee22490809b2822f22f8eb72a21c68a51b8782f1ba495145042fc050f7cd47
 SHA512:
-  metadata.gz: 7c0b34d32004e25dee56d9e71d1bb6d681e308847267e2fbca0d8f7c098f75c48d094d03862430bd31a7b67606941741ef9160e83986752301793135951cd9d2
-  data.tar.gz: e18cfc1e00817eaaf2b45adaed87640022818076e1fbef703cbe0efc308b5efc0755d2174f382185871d2ee47567c6272aad5ee8f8113a84273451e4ff0e307a
+  metadata.gz: d7c05c7dc064dfd6f4d7fbc99982ca91164cacbbe5effaa0a71537ff2387e19059dbc23e47cf794262e3f20be6a5e76257bb0024f5bdf96b91f339623c9e27ce
+  data.tar.gz: b05e8c34e6278dea52070dec7aeb782b8697dd85b6160477a02b680785f6ae9d2d3751f8a4cea30ff49e86b8a0d73ca80d0314b95c0002869a18661ede3d5371

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

@@ -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/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
@@ -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
+          self.approve_options = @args.pop
 
-          options = approve_options.slice!(:approval_key, :approval_queue, :approval_at)
+          options = slice_approval_options
 
-          args << options.to_hash if options.present?
+          @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_approval_key(options)
+
+          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,22 @@ 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
+          redis.incr(running_key)
+        end
+
+        def decrement_running
+          redis.decr(running_key)
+        end
+
         def pause
           redis.set(pause_key, true)
           redis.set(paused_count_key, 0)
@@ -165,6 +183,10 @@ 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
           @paused_count_key ||= "approve.job_queue.#{approval_key}.paused.count"
         end
@@ -172,3 +194,5 @@ module Resque
     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.7"
+      VERSION = "0.0.11"
     end
   end
 end

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

@@ -8,6 +8,9 @@
     <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

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

@@ -28,6 +28,9 @@
               order_param("num_jobs", @sort_by, @sort_order) }.to_param %>">
         Pending Jobs
       </a></th>
+      <th>
+        Num Running
+      </th>
       <th><a href="<%= u("approve") %>?<%=
         { sort:      "first_enqueued",
           page_size: @page_size,
@@ -64,3 +67,6 @@
 </div>
 <div class="approve_reset"/>
 <br/>
+<div>
+  Approval v<%= VERSION %>
+</div>

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

@@ -80,3 +80,6 @@
 <div class="approve_reset"/>
 
 <br/>
+<div>
+  Approval v<%= VERSION %>
+</div>

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

@@ -12,6 +12,10 @@
   </a>
 </p>
 
+<p>
+  Num active jobs in this queue = <%= pending_queue.num_running %>
+</p>
+
 <% if pending_queue.paused? %>
   <p>
     Paused. Skipped <%= pending_queue.num_ignored %> resume actions.
@@ -39,6 +43,11 @@
 
   <br/>
 
+  <form method="POST" action="<%= u("approve/reset_running") %>?<%=
+    { approval_key: pending_queue.approval_key }.to_param %>">
+    <input type="submit" name="" value="Reset Running"/>
+  </form>
+
   <form method="POST" action="<%= u("approve/delete_queue") %>?<%=
     { approval_key: pending_queue.approval_key }.to_param %>">
     <input type="submit" name="" value="Delete All"/>
@@ -74,3 +83,8 @@
 
 <div class="approve_reset"/>
 <br/>
+<div>
+  <p>
+    Approval v<%= VERSION %>
+  </p>
+</div>