resque-approve 0.0.1

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Resque
+  module Plugins
+    module Approve
+      # A class for cleaning out all redis values associated with
+      class Cleaner
+        include RedisAccess
+
+        class << self
+          def redis
+            @redis ||= Resque::Plugins::Approve::Cleaner.new.redis
+          end
+
+          def purge_all
+            keys = redis.keys("*")
+
+            return if keys.blank?
+
+            redis.del(*keys)
+          end
+
+          def cleanup_jobs
+            jobs = redis.keys("approve.pending_job.*")
+
+            jobs.each do |job_key|
+              job = Resque::Plugins::Approve::PendingJob.new(job_key[20..-1])
+
+              job.queue.verify_job(job)
+            end
+          end
+
+          def cleanup_queues
+            key_list = Resque::Plugins::Approve::ApprovalKeyList.new
+
+            key_list.queues.each do |pending_job_queue|
+              key_list.remove_key(pending_job_queue.approval_key) if pending_job_queue.num_jobs.zero?
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Resque
+  module Plugins
+    module Approve
+      # rubocop:disable Metrics/ClassLength
+
+      # A class representing a Pending job that is awaiting approval.
+      #
+      # Each job has the following values:
+      #   id          - The approve gem ID used to store and restore the job in Redis
+      #   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.
+      #
+      #                     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.
+      #
+      #                     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.
+      class PendingJob
+        include Resque::Plugins::Approve::RedisAccess
+        include Comparable
+
+        attr_reader :id
+
+        def initialize(id = SecureRandom.uuid, class_name: nil, args: [])
+          @approve_options = {}
+          @id              = id
+          @class_name      = class_name.is_a?(String) ? class_name : class_name&.name
+          self.args        = args
+        end
+
+        def <=>(other)
+          return nil unless other.is_a?(Resque::Plugins::Approve::PendingJob)
+
+          id <=> other.id
+        end
+
+        def class_name
+          @class_name ||= stored_values[:class_name]
+        end
+
+        def args
+          @args = if @args.present?
+                    @args
+                  else
+                    Array.wrap(decode_args(stored_values[:args]))
+                  end
+        end
+
+        def args=(value)
+          if value.nil?
+            @args = []
+          else
+            @args = Array.wrap(value).dup
+
+            extract_approve_options
+          end
+        end
+
+        def approve_options
+          @approve_options = if @approve_options.present?
+                               @approve_options
+                             else
+                               (decode_args(stored_values[:approve_options])&.first || {}).with_indifferent_access
+                             end
+        end
+
+        def requires_approval?
+          @requires_approval ||= approve_options.key?(:approval_key) || approve_options[:requires_approval]
+        end
+
+        def approval_key
+          @approval_key ||= approve_options[:approval_key]
+        end
+
+        def approval_queue
+          @approval_queue ||= approve_options[:approval_queue] || Resque.queue_from_class(klass)
+        end
+
+        def approval_at
+          @approval_at ||= approve_options[:approval_at]&.to_time
+        end
+
+        def queue_time
+          @queue_time ||= stored_values[:queue_time]&.to_time
+        end
+
+        def enqueue_job
+          return_value = if approval_at.present?
+                           Resque.enqueue_at_with_queue approval_queue, approval_at, klass, *args
+                         else
+                           Resque.enqueue_to approval_queue, klass, *args
+                         end
+
+          delete
+
+          return_value
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def save!
+          redis.hset(job_key, "class_name", class_name)
+          redis.hset(job_key, "args", encode_args(*args))
+          redis.hset(job_key, "approve_options", encode_args(approve_options))
+          redis.hset(job_key, "queue_time", Time.now)
+        end
+
+        # rubocop:enable Metrics/AbcSize
+
+        def delete
+          # 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)
+
+          queue.remove_job(self)
+        end
+
+        def queue
+          @queue ||= Resque::Plugins::Approve::PendingJobQueue.new(approval_key)
+        end
+
+        private
+
+        def klass
+          @klass ||= class_name.constantize
+        end
+
+        def job_key
+          @job_key ||= "approve.pending_job.#{id}"
+        end
+
+        def stored_values
+          @stored_values ||= (redis.hgetall(job_key) || {}).with_indifferent_access
+        end
+
+        def extract_approve_options
+          return if args.blank? || !args[-1].is_a?(Hash)
+
+          self.approve_options = args.pop
+
+          options = approve_options.slice!(:approval_key, :approval_queue, :approval_at)
+
+          args << options.to_hash if options.present?
+        end
+
+        def encode_args(*args)
+          Resque.encode(args)
+        end
+
+        def decode_args(args_string)
+          return if args_string.blank?
+
+          Resque.decode(args_string)
+        end
+
+        def approve_options=(value)
+          @approve_options = (value&.dup || {}).with_indifferent_access
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Resque
+  module Plugins
+    module Approve
+      # A class representing a queue of Pending jobs.
+      #
+      # The queue is named with the approval_key for all of the jobs in the queue and contains a list of the jobs.
+      class PendingJobQueue
+        include Resque::Plugins::Approve::RedisAccess
+
+        attr_reader :approval_key
+
+        def initialize(approval_key)
+          @approval_key = approval_key
+        end
+
+        def delete
+          jobs.each(&:delete)
+        end
+
+        def remove_job(job)
+          redis.lrem(queue_key, 0, job.id)
+
+          remove_approval_key(job)
+        end
+
+        def verify_job(job)
+          ApprovalKeyList.new.add_key(job.approval_key)
+
+          ids = redis.lrange(queue_key, 0, -1)
+
+          return if ids.include?(job.id)
+
+          redis.lpush(queue_key, job.id)
+        end
+
+        def add_job(job)
+          redis.rpush(queue_key, job.id)
+
+          job.save!
+        end
+
+        def approve_one
+          id = redis.lpop(queue_key)
+
+          enqueue_job(id)
+        end
+
+        def approve_all
+          true while approve_one
+        end
+
+        def pop_job
+          id = redis.rpop(queue_key)
+
+          enqueue_job(id)
+        end
+
+        def remove_one
+          id = redis.lpop(queue_key)
+
+          delete_job(id)
+        end
+
+        def remove_all
+          true while remove_one
+        end
+
+        def remove_job_pop
+          id = redis.rpop(queue_key)
+
+          delete_job(id)
+        end
+
+        def paged_jobs(page_num = 1, job_page_size = nil)
+          job_page_size ||= 20
+          job_page_size = job_page_size.to_i
+          job_page_size = 20 if job_page_size < 1
+          start         = (page_num - 1) * job_page_size
+          start         = 0 if start >= num_jobs || start.negative?
+
+          jobs(start, start + job_page_size - 1)
+        end
+
+        def jobs(start = 0, stop = -1)
+          redis.lrange(queue_key, start, stop).map { |id| Resque::Plugins::Approve::PendingJob.new(id) }
+        end
+
+        def num_jobs
+          redis.llen(queue_key)
+        end
+
+        def first_enqueued
+          jobs(0, 0).first&.queue_time
+        end
+
+        private
+
+        def remove_approval_key(job)
+          return unless job.class_name.constantize.auto_delete_approval_key
+
+          ApprovalKeyList.new.remove_key(approval_key) if num_jobs.zero?
+        end
+
+        def enqueue_job(id)
+          return false unless id.present?
+
+          Resque::Plugins::Approve::PendingJob.new(id).enqueue_job
+
+          true
+        end
+
+        def delete_job(id)
+          return false unless id.present?
+
+          Resque::Plugins::Approve::PendingJob.new(id).delete
+
+          true
+        end
+
+        def queue_key
+          @queue_key ||= "approve.job_queue.#{approval_key}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Resque
+  module Plugins
+    module Approve
+      # A module to add a `redis` method for a class in this gem that needs redis to get a reids object that is namespaced.
+      module RedisAccess
+        NAME_SPACE = "Resque::Plugins::Approve::"
+
+        def redis
+          @redis ||= Redis::Namespace.new(NAME_SPACE, redis: Resque.redis)
+        end
+      end
+    end
+  end
+end

data/lib/resque/plugins/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Resque
+  module Plugins
+    module Approve
+      VERSION = "0.0.1"
+    end
+  end
+end

data/lib/resque/server/public/approve.css

@@ -0,0 +1,56 @@
+.approve_pagination_block {
+    width:           100%;
+    display:         flex;
+    justify-content: space-between;
+    margin-bottom:   5px;
+}
+
+.approve_first_page {
+    margin-right: 5px;
+}
+
+.approve_prev_page {
+    margin-right: 5px;
+    margin-left:  5px;
+}
+
+.approve_page {
+    margin-right: 5px;
+    margin-left:  5px;
+}
+
+.approve_next_page {
+    margin-right: 5px;
+    margin-left:  5px;
+}
+
+.approve_last_page {
+    margin-left: 5px;
+}
+
+.table_container {
+    width:      100%;
+    overflow-x: scroll;
+}
+
+.approve_error {
+    background-color: lightcoral;
+}
+
+.approve_linear_history_div {
+    margin-top: 5px;
+    float:      left;
+}
+
+#approve_search_div {
+    float:         right;
+    margin-bottom: 10px;
+}
+
+#approve_search_div form {
+    margin-top: 0px;
+}
+
+.approve_reset {
+    clear: both;
+}

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

@@ -0,0 +1,67 @@
+<div class="approve_pagination_block">
+  <% total_pages = queue_list.job_queues.length / page_size %>
+  <% total_pages += 1 if queue_list.job_queues.length % page_size > 0 %>
+  <% page_num = 1 if page_num > total_pages || page_num < 1 %>
+  <% first_page = [1, page_num - 3].max %>
+  <% last_page = [total_pages, page_num + 3].min %>
+  <% last_page = page_num < 4 ? [total_pages, last_page + (4 - page_num)].min : last_page %>
+  <% first_page = page_num > total_pages - 3 ? [1, first_page + ((total_pages - page_num) - 3)].max : first_page %>
+
+  <% if total_pages > 1 %>
+    <div class="approve_prev_links">
+      <a href="<%= u("approve") %>?<%= { sort:      @sort_by,
+                                         page_size: page_size,
+                                         page_num:  1,
+                                         order:     @sort_order }.to_param %>"
+         class="approve_first_page"
+         disabled="<%= first_page > 1 %>">
+        &lt;&lt; First
+      </a>
+
+      <a href="<%= u("approve") %>?<%= { sort:      @sort_by,
+                                         page_size: page_size,
+                                         page_num:  [1, page_num - 1].max,
+                                         order:     @sort_order }.to_param %>"
+         class="approve_prev_page"
+         disabled="<%= page_num > 1 %>">
+        &lt; Prev
+      </a>
+    </div>
+
+    <div class="approve_pages">
+      <% (first_page..last_page).each do |page_number| %>
+        <% if page_number != page_num %>
+          <a href="<%= u("approve") %>?<%= { sort:      @sort_by,
+                                             page_size: page_size,
+                                             page_num:  page_number,
+                                             order:     @sort_order }.to_param %>"
+             class="approve_page">
+            <%= page_number %>
+          </a>
+        <% else %>
+          <%= page_number %>
+        <% end %>
+      <% end %>
+    </div>
+
+    <div class="approve_next_links">
+      <a href="<%= u("approve") %>?<%= { sort:      @sort_by,
+                                         page_size: page_size,
+                                         page_num:  [total_pages, page_num + 1].min,
+                                         order:     @sort_order }.to_param %>"
+         class="approve_next_page"
+         disabled="<%= page_num < last_page %>">
+        Next &gt;
+      </a>
+
+      <a href="<%= u("approve") %>?<%= { sort:      @sort_by,
+                                         page_size: page_size,
+                                         page_num:  total_pages,
+                                         order:     @sort_order }.to_param %>"
+         class="approve_last_page"
+         disabled="<%= last_page < total_pages %>">
+        Last &gt;&gt;
+      </a>
+    </div>
+  <% end %>
+</div>