resque-approve 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3dff2c5624ce3cd6a6890ca1637e18f883d43818
+  data.tar.gz: 4b85968da335eeb487665b6e192d3694f37e3566
+SHA512:
+  metadata.gz: 0a66cf31313bd8759eb15ac36ac59a09610bbe625529a87ec5fa3325967beb03ab0a689bce3a1ff51a9db8ede966a107bef0a54c2fece77b6944e380e5a230bf
+  data.tar.gz: d9636599c8dcfb360b192855182d2438a1ed4c2d1957cdf82db948664a1bab2900702eef52b6911e1b08d87dfd6bab72e6fac5ce28deadce50fffe00d15be9c8

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 RealNobody
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+begin
+  require "bundler/setup"
+rescue LoadError
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
+end
+
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "ResqueApprove"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.rdoc")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+Bundler::GemHelper.install_tasks
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "lib"
+  t.libs << "rspec"
+  t.pattern = "spec/**/*_spec.rb"
+  t.verbose = false
+end
+
+task default: :test

data/lib/resque-approve.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "resque"
+require File.expand_path(File.join("resque", "plugins", "approve", "redis_access"), File.dirname(__FILE__))
+require File.expand_path(File.join("resque", "plugins", "approve", "pending_job"), File.dirname(__FILE__))
+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"), File.dirname(__FILE__))

data/lib/resque/approve_server.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require "resque"
+require "resque/server"
+require "resque-approve"
+require "action_view/helpers/output_safety_helper"
+require "action_view/helpers/capture_helper"
+require "action_view/helpers/date_helper"
+
+# rubocop:disable Metrics/ModuleLength
+
+module Resque
+  # Extends Resque Web Based UI.
+  # Structure has been borrowed from ResqueHistory.
+  module ApproveServer
+    include ActionView::Helpers::DateHelper
+
+    class << self
+      def erb_path(filename)
+        File.join(File.dirname(__FILE__), "server", "views", filename)
+      end
+
+      def public_path(filename)
+        File.join(File.dirname(__FILE__), "server", "public", filename)
+      end
+
+      def included(base)
+        add_page_views(base)
+        add_button_callbacks(base)
+        add_static_files(base)
+      end
+
+      private
+
+      def add_page_views(base)
+        approval_keys(base)
+        job_list(base)
+        job_details(base)
+      end
+
+      def approval_keys(base)
+        approval_key_params(base)
+
+        base.class_eval do
+          get "/approve" do
+            set_approval_key_params
+
+            erb File.read(Resque::ApproveServer.erb_path("approval_keys.erb"))
+          end
+        end
+      end
+
+      def approval_key_params(base)
+        base.class_eval do
+          def set_approval_key_params
+            @sort_by    = params[:sort] || "approval_key"
+            @sort_order = params[:order] || "desc"
+            @page_num   = (params[:page_num] || 1).to_i
+            @page_size  = (params[:page_size] || 20).to_i
+          end
+        end
+      end
+
+      def job_list(base)
+        job_list_params(base)
+
+        base.class_eval do
+          get "/approve/job_list" do
+            set_job_list_params_params
+
+            erb File.read(Resque::ApproveServer.erb_path("job_list.erb"))
+          end
+        end
+      end
+
+      def job_list_params(base)
+        base.class_eval do
+          def set_job_list_params_params
+            @approval_key = params[:approval_key]
+            @page_num     = (params[:page_num] || 1).to_i
+            @page_size    = (params[:page_size] || 20).to_i
+          end
+        end
+      end
+
+      def job_details(base)
+        base.class_eval do
+          get "/approve/job_details" do
+            @job_id = params[:job_id]
+
+            erb File.read(Resque::ApproveServer.erb_path("job_details.erb"))
+          end
+        end
+      end
+
+      def add_static_files(base)
+        base.class_eval do
+          get %r{approve/public/([a-z_]+\.[a-z]+)} do
+            send_file Resque::ApproveServer.public_path(params[:captures]&.first)
+          end
+        end
+      end
+
+      def add_button_callbacks(base)
+        audit_jobs(base)
+        audit_queues(base)
+        delete_all_queues(base)
+        approve_all_queues(base)
+        delete_queue(base)
+        delete_one_queue(base)
+        approve_queue(base)
+        approve_one_queue(base)
+        delete_job(base)
+        approve_job(base)
+      end
+
+      def audit_jobs(base)
+        base.class_eval do
+          post "/approve/audit_jobs" do
+            Resque::Plugins::Approve::Cleaner.cleanup_jobs
+
+            redirect u("approve")
+          end
+        end
+      end
+
+      def audit_queues(base)
+        base.class_eval do
+          post "/approve/audit_queues" do
+            Resque::Plugins::Approve::Cleaner.cleanup_queues
+
+            redirect u("approve")
+          end
+        end
+      end
+
+      def delete_all_queues(base)
+        base.class_eval do
+          post "/approve/delete_all_queues" do
+            Resque::Plugins::Approve::ApprovalKeyList.new.delete_all
+
+            redirect u("approve")
+          end
+        end
+      end
+
+      def approve_all_queues(base)
+        base.class_eval do
+          post "/approve/approve_all_queues" do
+            Resque::Plugins::Approve::ApprovalKeyList.new.approve_all
+
+            redirect u("approve")
+          end
+        end
+      end
+
+      def delete_queue(base)
+        base.class_eval do
+          post "/approve/delete_queue" do
+            Resque::Plugins::Approve::PendingJobQueue.new(params[:approval_key]).delete
+            Resque::Plugins::Approve::ApprovalKeyList.new.remove_key(params[:approval_key])
+
+            redirect u("approve")
+          end
+        end
+      end
+
+      def delete_one_queue(base)
+        base.class_eval do
+          post "/approve/delete_one_queue" do
+            Resque::Plugins::Approve::PendingJobQueue.new(params[:approval_key]).remove_one
+
+            redirect u("approve/job_list?#{{ approval_key: params[:approval_key] }.to_param}")
+          end
+        end
+      end
+
+      def approve_queue(base)
+        base.class_eval do
+          post "/approve/approve_queue" do
+            Resque::Plugins::Approve::PendingJobQueue.new(params[:approval_key]).approve_all
+
+            redirect u("approve/job_list?#{{ approval_key: params[:approval_key] }.to_param}")
+          end
+        end
+      end
+
+      def approve_one_queue(base)
+        base.class_eval do
+          post "/approve/approve_one_queue" do
+            Resque::Plugins::Approve::PendingJobQueue.new(params[:approval_key]).approve_one
+
+            redirect u("approve/job_list?#{{ approval_key: params[:approval_key] }.to_param}")
+          end
+        end
+      end
+
+      def delete_job(base)
+        base.class_eval do
+          post "/approve/delete_job" do
+            job = Resque::Plugins::Approve::PendingJob.new(params[:job_id])
+
+            job.approval_key
+            job.delete
+
+            redirect u("approve/job_list?#{{ approval_key: job.approval_key }.to_param}")
+          end
+        end
+      end
+
+      def approve_job(base)
+        base.class_eval do
+          post "/approve/approve_job" do
+            job = Resque::Plugins::Approve::PendingJob.new(params[:job_id])
+
+            job.enqueue_job
+
+            redirect u("approve/job_list?#{{ approval_key: job.approval_key }.to_param}")
+          end
+        end
+      end
+    end
+
+    Resque::Server.tabs << "Approve"
+  end
+end
+
+Resque::Server.class_eval do
+  include Resque::ApproveServer
+end
+
+# rubocop:enable Metrics/ModuleLength

data/lib/resque/plugins/approve.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/core_ext/numeric/time"
+
+module Resque
+  module Plugins
+    # Include in a Resque Job to keep allow the hooks to run.
+    module Approve
+      extend ActiveSupport::Concern
+
+      included do
+        self.auto_delete_approval_key = false
+      end
+
+      class << self
+        def approve(approval_key)
+          PendingJobQueue.new(approval_key).approve_all
+        end
+
+        def approve_one(approval_key)
+          PendingJobQueue.new(approval_key).approve_one
+        end
+
+        def remove(approval_key)
+          PendingJobQueue.new(approval_key).remove_all
+        end
+
+        def remove_one(approval_key)
+          PendingJobQueue.new(approval_key).remove_one
+        end
+      end
+
+      # The class methods added to the job class that is being enqueued to determine if it should be
+      # shunted to the list of pending jobs, or enqueued.
+      module ClassMethods
+        def auto_delete_approval_key=(value)
+          @auto_delete_approval_key = value
+        end
+
+        def auto_delete_approval_key
+          @auto_delete_approval_key
+        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.
+        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?
+            ApprovalKeyList.new.add_job(job)
+
+            raise Resque::Job::DontPerform, "The job has not been approved yet."
+          else
+            true
+          end
+        end
+
+        # Check if the job needs to be approved, and if so, do not enqueue it.
+        def before_enqueue_approve(*args)
+          job = PendingJob.new(SecureRandom.uuid, class_name: name, args: args)
+
+          if job.requires_approval?
+            ApprovalKeyList.new.add_job(job)
+            false
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Resque
+  module Plugins
+    module Approve
+      # A class representing a queue of Pending job_queues.
+      #
+      # The queue is named with the approval_key for all of the job_queues in the queue and contains a list of the job_queues.
+      class ApprovalKeyList
+        include Resque::Plugins::Approve::RedisAccess
+
+        def order_param(sort_option, current_sort, current_order)
+          current_order ||= "asc"
+
+          if sort_option == current_sort
+            current_order == "asc" ? "desc" : "asc"
+          else
+            "asc"
+          end
+        end
+
+        def remove_key(key)
+          redis.srem(list_key, key)
+        end
+
+        def add_key(key)
+          redis.sadd(list_key, key)
+        end
+
+        def add_job(job)
+          add_key(job.approval_key)
+
+          Resque::Plugins::Approve::PendingJobQueue.new(job.approval_key).add_job(job)
+        end
+
+        def delete_all
+          queues.each do |queue|
+            queue.delete
+            remove_key(queue.approval_key)
+          end
+
+          redis.del(list_key)
+        end
+
+        def approve_all
+          queues.each(&:approve_all)
+        end
+
+        def queues(sort_key = :approval_key,
+                   sort_order = "asc",
+                   page_num = 1,
+                   queue_page_size = 20)
+          queue_page_size = queue_page_size.to_i
+          queue_page_size = 20 if queue_page_size < 1
+
+          job_queues = sorted_job_queues(sort_key)
+
+          page_start = (page_num - 1) * queue_page_size
+          page_start = 0 if page_start > job_queues.length || page_start.negative?
+
+          (sort_order == "desc" ? job_queues.reverse : job_queues)[page_start..(page_start + queue_page_size - 1)]
+        end
+
+        def job_queues
+          @job_queues ||= queue_keys.map { |approval_key| Resque::Plugins::Approve::PendingJobQueue.new(approval_key) }
+        end
+
+        def queue_keys
+          @queue_keys ||= redis.smembers(list_key)
+        end
+
+        def num_queues
+          queue_keys.length
+        end
+
+        private
+
+        def list_key
+          @list_key ||= "approve.approval_key_list"
+        end
+
+        def sorted_job_queues(sort_key)
+          job_queues.sort_by do |job_queue|
+            approval_key_sort_value(job_queue, sort_key)
+          end
+        end
+
+        def approval_key_sort_value(job_queue, sort_key)
+          case sort_key.to_sym
+            when :approval_key,
+                :num_jobs
+              job_queue.public_send(sort_key)
+            when :first_enqueued
+              job_queue.public_send(sort_key).to_s
+          end
+        end
+      end
+    end
+  end
+end