resque 2.1.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b930a952313756e06d51bb6daa493ebeed0c4498940e46d24300f7fafdac36b3
-  data.tar.gz: ea821158f150dbf5740dff8cb210be0f7507c1e183acd3a902308f0ef91e7f2c
+  metadata.gz: 26c77950669242c68e75f64480a798486a84ac3aa2c4bd22c5ae212caa6bf57c
+  data.tar.gz: bea29587e61e5b2a41c675ff26afb69cca7891613212e0d052a41a43ce5404b4
 SHA512:
-  metadata.gz: d266f8019b93add5de76d0d3e5a460c2a03c3fc04b3d71c65f296269c7e286875b6b1925d31d01699c952d14319164cab39062f9310314fed0b4229b92f47821
-  data.tar.gz: d375348987a655202483adb5eccb253ed07eea17d88749c04837e0ec05dad948805cb371500ac42b11650595327875f0af56e9c3501261e8223f6c1fbfff5f5f
+  metadata.gz: 81f58c37a382d84e6f168ad9ada384ac160c223fa5cc1070c251ad01c8840389af78736af263aa3cd594dcd77970a2539a7f44082dca07a25f236c6d147625b4
+  data.tar.gz: f28ffa6efb6e8037cf3ec7d233f824b7190f97d91c4d3d6ba00399e6533f2958581e98422a31068a9145dd789f63d1caff58ca8744905a1cf747b02eaeed9d02

data/HISTORY.md

@@ -1,14 +1,40 @@
-## Unreleased
+## 2.3.0
+
+### Fixed
+
+* Fix NoMethodError: undefined method 'application' for Rails:Module when Rails module is defined but not a full Rails app (#1799)
+* Fix deprecation warnings in Redis#pipelined for redis 4.6 (#1806)
+* Add Ruby syntax highlighting to remaining markdown docs (#1802)
+* Fix pagination section (#1809)
+* Fix `before_run` undefined local variable or method `runner` (#1811)
+
+### Added
+
+* Added support for pausing all workers by setting the Redis key `pause-all-workers` to string value "true" (#1803)
+
+## 2.2.1
+
+### Fixed
+
+* Escape HTML from the params to avoid XSS (#1790)
+* Remove vegas as a dependency (#1780)
+
+### Added
+
+* Add support for specifying queues that workers should ignore when using globs
+* Allow plugins to have spaces in their name (#1718)
+
+## 2.2.0
 
 ### Added
 
-*
-*
+* Add 'Retry Failed Jobs' button to Failed page
 
 ### Fixed
 
-*
-*
+* Loading railtie when it did not exist #1765
+* Fix closing parent Redis connection in child process after fork
+* Fix the failed queues list on /queues UI when the RedisMultiQueue backend is used #1638
 
 ## 2.1.0
 

data/README.markdown

@@ -4,19 +4,15 @@ Resque
 [![Gem Version](https://badge.fury.io/rb/resque.svg)](https://rubygems.org/gems/resque)
 [![Build Status](https://github.com/resque/resque/actions/workflows/ci.yml/badge.svg)](https://github.com/resque/resque/actions/workflows/ci.yml)
 
+Introduction
+------------
+
 Resque (pronounced like "rescue") is a Redis-backed library for creating
 background jobs, placing those jobs on multiple queues, and processing
 them later.
 
----------
-### Note on the future of this repo
-
-Would you like to be involved in Resque? Do you have thoughts about what 
-Resque should be and do going forward? There's currently an [open discussion here](https://github.com/resque/resque/issues/1759) 
-on just that topic, so please feel free to join in. We'd love to hear your thoughts
-and/or have people volunteer to be a part of the project!
+For the backstory, philosophy, and history of Resque's beginnings, please see [the blog post](http://github.com/blog/542-introducing-resque) (2009).
 
----------
 Background jobs can be any Ruby class or module that responds to
 `perform`. Your existing classes can easily be converted to background
 jobs or you can create new classes specifically to do work. Or, you
@@ -29,10 +25,11 @@ three parts:
 2. A Rake task for starting a worker which processes jobs
 3. A Sinatra app for monitoring queues, jobs, and workers.
 
-Resque workers can be distributed between multiple machines,
-support priorities, are resilient to memory bloat / "leaks," are
-optimized for REE (but work on MRI and JRuby), tell you what they're
-doing, and expect failure.
+Resque workers can be  given multiple queues (a "queue list"),
+distributed between multiple machines,
+run anywhere with network access to the Redis server,
+support priorities, are resilient to memory bloat / "leaks,"
+tell you what they're doing, and expect failure.
 
 Resque queues are persistent; support constant time, atomic push and
 pop (thanks to Redis); provide visibility into their contents; and
@@ -45,42 +42,15 @@ general usage stats, and helps you track failures.
 Resque now supports Ruby 2.3.0 and above.
 We will also only be supporting Redis 3.0 and above going forward.
 
+### Note on the future of Resque
 
-Table of Contents
------------------
+Would you like to be involved in Resque? Do you have thoughts about what
+Resque should be and do going forward? There's currently an [open discussion here](https://github.com/resque/resque/issues/1759)
+on just that topic, so please feel free to join in. We'd love to hear your thoughts
+and/or have people volunteer to be a part of the project!
 
-* [Overview](#overview)
-* [Installation](#installation)
-* [Running Workers](#running-workers)
-* [The Front End](#the-front-end)
-* [Jobs](#jobs)
-* [Configuration](#configuration)
-* * [Redis](#redis)
-* * [Logging](#logging)
-* * [Namespaces](#namespaces)
-* * [Storing Statistics](#storing-statistics)
-* [Plugins and Hooks](#plugins-and-hooks)
-* [Additional Information](#additional-information)
-* * [Resque vs DelayedJob](#resque-vs-delayedjob)
-* * [Forking](#forking)
-* * [Signals](#signals)
-* * [Heroku](#heroku)
-* * [Monitoring](#monitoring)
-* * [Mysql::Error](#mysqlerror-mysql-server-has-gone-away)
-* [Development](#development)
-* * [Demo](#demo)
-* * [Contributing](#contributing)
-* [Questions](#questions)
-* [Meta](#meta)
-* [Author](#author)
-
-Overview
---------
-
-For the backstory, philosophy, and history of Resque's beginnings, please see [the blog post](http://github.com/blog/542-introducing-resque).
-
-Resque allows you to create jobs and place them on a queue, then,
-later, pull those jobs off the queue and process them.
+Example
+-------
 
 Resque jobs are Ruby classes (or modules) which respond to the
 `perform` method. Here's an example:
@@ -140,10 +110,6 @@ This starts one Resque worker and tells it to work off the
 find any more, at which point it will sleep for a small period and
 repeatedly poll the queue for more jobs.
 
-Workers can be given multiple queues (a "queue list") and run on
-multiple machines. In fact they can be run anywhere with network
-access to the Redis server.
-
 Installation
 ------------
 
@@ -165,7 +131,7 @@ require 'resque/tasks'
 require 'your/app' # Include this line if you want your workers to have access to your application
 ```
 
-#### Rails 3+
+#### Rails
 
 To make resque specific changes, you can override the `resque:setup` job in `lib/tasks` (ex: `lib/tasks/resque.rake`). GitHub's setup task looks like this:
 
@@ -253,6 +219,22 @@ Or, prioritize some queues above `*`:
 
     # QUEUE=critical,* rake resque:work
 
+#### Running All Queues Except for Some
+
+If you want your workers to work off of all queues except for some,
+you can use negation:
+
+    $ QUEUE=*,!low rake resque:work
+
+Negated globs also work. The following will instruct workers to work
+off of all queues except those beginning with `file_`:
+
+    $ QUEUE=*,!file_* rake resque:work
+
+Note that the order in which negated queues are specified does not
+matter, so `QUEUE=*,!file_*` and `QUEUE=!file_*,*` will have the same
+effect.
+
 #### Process IDs (PIDs)
 
 There are scenarios where it's helpful to record the PID of a resque
@@ -331,9 +313,9 @@ run Rack::URLMap.new \
 Check `examples/demo/config.ru` for a functional example (including
 HTTP basic auth).
 
-#### Rails 3+
+#### Rails
 
-You can also mount Resque on a subpath in your existing Rails 3 app by adding `require 'resque/server'` to the top of your routes file or in an initializer then adding this to `routes.rb`:
+You can also mount Resque on a subpath in your existing Rails app by adding `require 'resque/server'` to the top of your routes file or in an initializer then adding this to `routes.rb`:
 
 ``` ruby
 mount Resque::Server.new, :at => "/resque"
@@ -687,6 +669,12 @@ complicated.
 
 Workers instead handle their own state.
 
+#### `at_exit` Callbacks
+
+Resque uses `Kernel#exit!` for exiting its workers' child processes. So any `at_exit` callback defined in your application won't be executed when the job is finished and the child process exits.
+
+You can alter this behavior by setting the `RUN_AT_EXIT_HOOKS` environment variable.
+
 #### Parents and Children
 
 Here's a parent / child pair doing some work:
@@ -728,7 +716,7 @@ If you want to kill a stale or stuck child and shutdown, use `TERM`
 
 If you want to stop processing jobs, but want to leave the worker running
 (for example, to temporarily alleviate load), use `USR2` to stop processing,
-then `CONT` to start it again.
+then `CONT` to start it again. It's also possible to [pause all workers](#pausing-all-workers).
 
 #### Heroku
 
@@ -752,6 +740,22 @@ time to complete before being forced to die.
 
 * `RESQUE_TERM_TIMEOUT` - By default you have a few seconds to handle `Resque::TermException` in your job. `RESQUE_TERM_TIMEOUT` and `RESQUE_PRE_SHUTDOWN_TIMEOUT` must be lower than the [heroku dyno timeout](https://devcenter.heroku.com/articles/limits#exit-timeout).
 
+#### Pausing all workers
+
+Workers will not process pending jobs if the Redis key `pause-all-workers` is set with the string value "true".
+
+``` ruby
+Resque.redis.set('pause-all-workers', 'true')
+```
+
+Nothing happens to jobs that are already being processed by workers.
+
+Unpause by removing the Redis key `pause-all-workers`.
+
+``` ruby
+Resque.redis.del('pause-all-workers')
+```
+
 #### Monitoring
 
 ##### god
@@ -770,7 +774,7 @@ send patches for any tweaks or improvements you can make to it.
 
 If your workers remain idle for too long they may lose their MySQL connection. Depending on your version of Rails, we recommend the following:
 
-##### Rails 3.x
+##### Rails
 In your `perform` method, add the following line:
 
 ``` ruby
@@ -861,7 +865,6 @@ Meta
 * Home: <http://github.com/resque/resque>
 * Docs: <http://rubydoc.info/gems/resque>
 * Bugs: <http://github.com/resque/resque/issues>
-* Chat: <irc://irc.freenode.net/resque>
 * Gems: <https://rubygems.org/gems/resque>
 
 This project uses [Semantic Versioning](http://semver.org/)

data/bin/resque-web

@@ -1,31 +1,15 @@
 #!/usr/bin/env ruby
 
 $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
-begin
-  require 'vegas'
-rescue LoadError
-  require 'rubygems'
-  require 'vegas'
-end
-require 'resque/server'
-
 
-Vegas::Runner.new(Resque::Server, 'resque-web', {
-  :before_run => lambda {|v|
-    path = (ENV['RESQUECONFIG'] || v.args.first)
-    load path.to_s.strip if path
-  }
-}) do |runner, opts, app|
-  opts.on('-N NAMESPACE', "--namespace NAMESPACE", "set the Redis namespace") {|namespace|
-    runner.logger.info "Using Redis namespace '#{namespace}'"
-    Resque.redis.namespace = namespace
-  }
-  opts.on('-r redis-connection', "--redis redis-connection", "set the Redis connection string") {|redis_conf|
-    runner.logger.info "Using Redis connection '#{redis_conf}'"
-    Resque.redis = redis_conf
-  }
-  opts.on('-a url-prefix', "--append url-prefix", "set reverse_proxy friendly prefix to links") {|url_prefix|
-    runner.logger.info "Using URL Prefix '#{url_prefix}'"
-    Resque::Server.url_prefix = url_prefix
-  }
+if !!(RUBY_PLATFORM =~ /(mingw|bccwin|wince|mswin32)/i)
+  begin
+    require 'win32/process'
+  rescue
+    puts "Sorry, in order to use resque-web on Windows you need the win32-process gem:",
+         "gem install win32-process"
+  end
 end
+require 'resque/web_runner'
+
+Resque::WebRunner.new(*ARGV)

data/lib/resque/data_store.rb

@@ -76,9 +76,10 @@ module Resque
       @redis.inspect
     end
 
-    # Force a reconnect to Redis.
+    # Force a reconnect to Redis without closing the connection in the parent
+    # process after a fork.
     def reconnect
-      @redis._client.reconnect
+      @redis._client.connect
     end
 
     # Returns an array of all known Resque keys in Redis. Redis' KEYS operation
@@ -99,9 +100,9 @@ module Resque
         @redis = redis
       end
       def push_to_queue(queue,encoded_item)
-        @redis.pipelined do
-          watch_queue(queue)
-          @redis.rpush redis_key_for_queue(queue), encoded_item
+        @redis.pipelined do |piped|
+          watch_queue(queue, redis: piped)
+          piped.rpush redis_key_for_queue(queue), encoded_item
         end
       end
 
@@ -128,9 +129,9 @@ module Resque
       end
 
       def remove_queue(queue)
-        @redis.pipelined do
-          @redis.srem(:queues, queue.to_s)
-          @redis.del(redis_key_for_queue(queue))
+        @redis.pipelined do |piped|
+          piped.srem(:queues, queue.to_s)
+          piped.del(redis_key_for_queue(queue))
         end
       end
 
@@ -144,8 +145,8 @@ module Resque
       end
 
       # Private: do not call
-      def watch_queue(queue)
-        @redis.sadd(:queues, queue.to_s)
+      def watch_queue(queue, redis: @redis)
+        redis.sadd(:queues, queue.to_s)
       end
 
       # Private: do not call
@@ -236,24 +237,24 @@ module Resque
       end
 
       def register_worker(worker)
-        @redis.pipelined do
-          @redis.sadd(:workers, worker)
-          worker_started(worker)
+        @redis.pipelined do |piped|
+          piped.sadd(:workers, worker)
+          worker_started(worker, redis: piped)
         end
       end
 
-      def worker_started(worker)
-        @redis.set(redis_key_for_worker_start_time(worker), Time.now.to_s)
+      def worker_started(worker, redis: @redis)
+        redis.set(redis_key_for_worker_start_time(worker), Time.now.to_s)
       end
 
       def unregister_worker(worker, &block)
-        @redis.pipelined do
-          @redis.srem(:workers, worker)
-          @redis.del(redis_key_for_worker(worker))
-          @redis.del(redis_key_for_worker_start_time(worker))
-          @redis.hdel(HEARTBEAT_KEY, worker.to_s)
+        @redis.pipelined do |piped|
+          piped.srem(:workers, worker)
+          piped.del(redis_key_for_worker(worker))
+          piped.del(redis_key_for_worker_start_time(worker))
+          piped.hdel(HEARTBEAT_KEY, worker.to_s)
 
-          block.call
+          block.call redis: piped
         end
       end
 
@@ -287,9 +288,9 @@ module Resque
       end
 
       def worker_done_working(worker, &block)
-        @redis.pipelined do
-          @redis.del(redis_key_for_worker(worker))
-          block.call
+        @redis.pipelined do |piped|
+          piped.del(redis_key_for_worker(worker))
+          block.call redis: piped
         end
       end
 
@@ -316,16 +317,16 @@ module Resque
         @redis.get("stat:#{stat}").to_i
       end
 
-      def increment_stat(stat, by = 1)
-        @redis.incrby("stat:#{stat}", by)
+      def increment_stat(stat, by = 1, redis: @redis)
+        redis.incrby("stat:#{stat}", by)
       end
 
       def decremet_stat(stat, by = 1)
         @redis.decrby("stat:#{stat}", by)
       end
 
-      def clear_stat(stat)
-        @redis.del("stat:#{stat}")
+      def clear_stat(stat, redis: @redis)
+        redis.del("stat:#{stat}")
       end
     end
   end

data/lib/resque/failure.rb

@@ -91,6 +91,12 @@ module Resque
       backend.clear(queue)
     end
 
+    def self.clear_retried
+      each do |index, job|
+        remove(index) unless job['retried_at'].nil?
+      end
+    end
+
     def self.requeue(id, queue = nil)
       backend.requeue(id, queue)
     end

data/lib/resque/server/helpers.rb

@@ -9,7 +9,9 @@ Resque::Server.helpers do
 
   def failed_multiple_queues?
     return @multiple_failed_queues if defined?(@multiple_failed_queues)
-    @multiple_failed_queues = Resque::Failure.queues.size > 1
+
+    @multiple_failed_queues = Resque::Failure.queues.size > 1 ||
+      (defined?(Resque::Failure::RedisMultiQueue) && Resque::Failure.backend == Resque::Failure::RedisMultiQueue)
   end
 
   def failed_size

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

@@ -1 +1 @@
-<h1 style="font-size:110%;font-family:Arial, sans-serif;"><%= error %></h1>
+<h1 style="font-size:110%;font-family:Arial, sans-serif;"><%= escape_html(error) %></h1>

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

@@ -1,15 +1,21 @@
 <% if failed_multiple_queues? && !params[:queue] %>
 <h1>All Failed Queues: <%= Resque::Failure.queues.size %> total</h1>
 <% else %>
-<h1>Failed Jobs <%= "on '#{params[:queue]}'" if params[:queue] %> <%= "with class '#{params[:class]}'" if params[:class] %></h1>
+<h1>Failed Jobs <%= "on '#{escape_html(params[:queue])}'" if params[:queue] %> <%= "with class '#{escape_html(params[:class])}'" if params[:class] %></h1>
 <% end %>
 
 <% unless failed_size.zero? %>
 <form method="POST" action="<%= u "failed#{'/' + params[:queue] if params[:queue]}/clear" %>">
-  <input type="submit" name="" value="Clear <%= params[:queue] ? "'#{params[:queue]}'" : 'Failed' %> Jobs" class="confirmSubmission" />
+  <input type="submit" name="" value="Clear <%= params[:queue] ? "'#{escape_html(params[:queue])}'" : 'Failed' %> Jobs" class="confirmSubmission" />
 </form>
+
+<% unless params[:queue] %>
+  <form method="POST" action="<%= u "failed/clear_retried" %>">
+    <input type="submit" name="" value="Clear Retried Jobs" onclick='return confirm("Are you absolutely sure? This cannot be undone.");' />
+  </form>
+<% end %>
 <form method="POST" action="<%= u "failed#{'/' + params[:queue] if params[:queue]}/requeue/all" %>">
-  <input type="submit" name="" value="Retry <%= params[:queue] ? "'#{params[:queue]}'" : 'Failed' %> Jobs" class="confirmSubmission" />
+  <input type="submit" name="" value="Retry <%= params[:queue] ? "'#{escape_html(params[:queue])}'" : 'Failed' %> Jobs" class="confirmSubmission" />
 </form>
 <% end %>
 

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

@@ -1,6 +1,8 @@
 <% if job['class'] == 'ActiveJob::QueueAdapters::ResqueAdapter::JobWrapper' %>
   <code><%= job['args'].first['job_class'] %></code>
-  <small><a href="http://edgeguides.rubyonrails.org/active_job_basics.html" target="_blank">(via ActiveJob)</a></small>
+  <small>
+    <a href="http://edgeguides.rubyonrails.org/active_job_basics.html" rel="noopener noreferrer" target="_blank">(via ActiveJob)</a>
+  </small>
 <% else %>
   <code><%= job['class'] %></code>
 <% end %>

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

@@ -1,5 +1,5 @@
 <% if key = params[:key] %>
-  <h1>Key "<%= key %>" is a <%= resque.redis.type key %></h1>
+  <h1>Key "<%= escape_html(key) %>" is a <%= resque.redis.type key %></h1>
   <h2>size: <%= redis_get_size(key) %></h2>
   <table>
     <tr>

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

@@ -37,7 +37,7 @@
 </div>
 
 <div id="footer">
-  <p>Powered by <a href="http://github.com/resque/resque">Resque</a> v<%=Resque::Version%></p>
+  <p>Powered by <a href="http://github.com/resque/resque">Resque</a> v<%=Resque::VERSION%></p>
   <p>Connected to Redis namespace <%= Resque.redis.namespace %> on <%=Resque.redis_id%></p>
 </div>
 

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

@@ -7,7 +7,7 @@
       <a href="<%= current_page %>?start=<%= start - per_page %>" class='less'>&laquo; Previous</a>
     <% end %>
 
-    <% (size / per_page.to_f - 1).ceil.times do |page_num| %>
+    <% (size / per_page.to_f).ceil.times do |page_num| %>
       <% if start == page_num * per_page %>
         <span><%= page_num + 1 %></span>
       <% else %>
@@ -15,7 +15,7 @@
       <% end %>
     <% end %>
 
-    <% if start + per_page <= size %>
+    <% if start + per_page < size %>
       <a href="<%= current_page %>?start=<%= start + per_page %>" class='more'>Next &raquo;</a>
     <% end %>
   </div>

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

@@ -2,7 +2,7 @@
 
 <% if current_queue = params[:id] %>
 
-  <h1>Pending jobs on <span class='hl'><%= h current_queue %></span></h1>
+  <h1>Pending jobs on <span class='hl'><%= h escape_html(current_queue) %></span></h1>
   <form method="POST" action="<%=u "/queues/#{current_queue}/remove" %>" class='remove-queue'>
     <input type='submit' name='' value='Remove Queue' class="confirmSubmission" />
   </form>

data/lib/resque/server.rb

@@ -53,7 +53,7 @@ module Resque
       def tab(name)
         dname = name.to_s.downcase
         path = url_path(dname)
-        "<li #{class_if_current(path)}><a href='#{path}'>#{name}</a></li>"
+        "<li #{class_if_current(path)}><a href='#{path.gsub(" ", "_")}'>#{name}</a></li>"
       end
 
       def tabs
@@ -205,6 +205,11 @@ module Resque
       redirect u('failed')
     end
 
+    post "/failed/clear_retried" do
+      Resque::Failure.clear_retried
+      redirect u('failed')
+    end
+
     post "/failed/:queue/clear" do
       Resque::Failure.clear params[:queue]
       redirect u('failed')

data/lib/resque/stat.rb

@@ -35,8 +35,8 @@ module Resque
     #
     # Can optionally accept a second int parameter. The stat is then
     # incremented by that amount.
-    def incr(stat, by = 1)
-      data_store.increment_stat(stat,by)
+    def incr(stat, by = 1, **opts)
+      data_store.increment_stat(stat, by, **opts)
     end
 
     # Increments a stat by one.
@@ -58,8 +58,8 @@ module Resque
     end
 
     # Removes a stat from Redis, effectively setting it to 0.
-    def clear(stat)
-      data_store.clear_stat(stat)
+    def clear(stat, **opts)
+      data_store.clear_stat(stat, **opts)
     end
   end
 end

data/lib/resque/tasks.rb

@@ -39,7 +39,7 @@ namespace :resque do
 
   # Preload app files if this is Rails
   task :preload => :setup do
-    if defined?(Rails)
+    if defined?(Rails) && Rails.respond_to?(:application)
       if Rails.application.config.eager_load
         ActiveSupport.run_load_hooks(:before_eager_load, Rails.application)
         Rails.application.config.eager_load_namespaces.each(&:eager_load!)

data/lib/resque/version.rb

@@ -1,3 +1,3 @@
 module Resque
-  Version = VERSION = '2.1.0'
+  VERSION = '2.3.0'
 end

data/lib/resque/web_runner.rb

@@ -0,0 +1,372 @@
+require 'open-uri'
+require 'logger'
+require 'optparse'
+require 'fileutils'
+require 'rack'
+require 'resque/server'
+
+# only used with `bin/resque-web`
+# https://github.com/resque/resque/pull/1780
+
+module Resque
+  WINDOWS = !!(RUBY_PLATFORM =~ /(mingw|bccwin|wince|mswin32)/i)
+  JRUBY = !!(RbConfig::CONFIG["RUBY_INSTALL_NAME"] =~ /^jruby/i)
+
+  class WebRunner
+    attr_reader :app, :app_name, :filesystem_friendly_app_name,
+      :rack_handler, :port, :options, :args
+
+    PORT       = 5678
+    HOST       = WINDOWS ? 'localhost' : '0.0.0.0'
+
+    def initialize(*runtime_args)
+      @options = runtime_args.last.is_a?(Hash) ? runtime_args.pop : {}
+
+      self.class.logger.level = options[:debug] ? Logger::DEBUG : Logger::INFO
+
+      @app      = Resque::Server
+      @app_name = 'resque-web'
+      @filesystem_friendly_app_name = @app_name.gsub(/\W+/, "_")
+
+      @args = load_options(runtime_args)
+
+      @rack_handler = (s = options[:rack_handler]) ? Rack::Handler.get(s) : setup_rack_handler
+
+      case option_parser.command
+      when :help
+        puts option_parser
+      when :kill
+        kill!
+      when :status
+        status
+      when :version
+        puts "resque #{Resque::VERSION}"
+        puts "rack #{Rack::VERSION.join('.')}"
+        puts "sinatra #{Sinatra::VERSION}" if defined?(Sinatra)
+      else
+        before_run
+        start unless options[:start] == false
+      end
+    end
+
+    def launch_path
+      if options[:launch_path].respond_to?(:call)
+        options[:launch_path].call(self)
+      else
+        options[:launch_path]
+      end
+    end
+
+    def app_dir
+      if !options[:app_dir] && !ENV['HOME']
+        raise ArgumentError.new("nor --app-dir neither ENV['HOME'] defined")
+      end
+      options[:app_dir] || File.join(ENV['HOME'], filesystem_friendly_app_name)
+    end
+
+    def pid_file
+      options[:pid_file] || File.join(app_dir, "#{filesystem_friendly_app_name}.pid")
+    end
+
+    def url_file
+      options[:url_file] || File.join(app_dir, "#{filesystem_friendly_app_name}.url")
+    end
+
+    def log_file
+      options[:log_file] || File.join(app_dir, "#{filesystem_friendly_app_name}.log")
+    end
+
+    def host
+      options.fetch(:host) { HOST }
+    end
+
+    def url
+      "http://#{host}:#{port}"
+    end
+
+    def before_run
+      if (redis_conf = options[:redis_conf])
+        logger.info "Using Redis connection '#{redis_conf}'"
+        Resque.redis = redis_conf
+      end
+      if (namespace = options[:redis_namespace])
+        logger.info "Using Redis namespace '#{namespace}'"
+        Resque.redis.namespace = namespace
+      end
+      if (url_prefix = options[:url_prefix])
+        logger.info "Using URL Prefix '#{url_prefix}'"
+        Resque::Server.url_prefix = url_prefix
+      end
+      app.set(options.merge web_runner: self)
+      path = (ENV['RESQUECONFIG'] || args.first)
+      load_config_file(path.to_s.strip) if path
+    end
+
+    def start(path = launch_path)
+      logger.info "Running with Windows Settings" if WINDOWS
+      logger.info "Running with JRuby" if JRUBY
+      logger.info "Starting '#{app_name}'..."
+
+      check_for_running(path)
+      find_port
+      write_url
+      launch!(url, path)
+      daemonize! unless options[:foreground]
+      run!
+    rescue RuntimeError => e
+      logger.warn "There was an error starting '#{app_name}': #{e}"
+      exit
+    end
+
+    def find_port
+      if @port = options[:port]
+        announce_port_attempted
+
+        unless port_open?
+          logger.warn "Port #{port} is already in use. Please try another. " +
+                      "You can also omit the port flag, and we'll find one for you."
+        end
+      else
+        @port = PORT
+        announce_port_attempted
+
+        until port_open?
+          @port += 1
+          announce_port_attempted
+        end
+      end
+    end
+
+    def announce_port_attempted
+      logger.info "trying port #{port}..."
+    end
+
+    def port_open?(check_url = nil)
+      begin
+        check_url ||= url
+        options[:no_proxy] ? uri_open(check_url, :proxy => nil) : uri_open(check_url)
+        false
+      rescue Errno::ECONNREFUSED, Errno::EPERM, Errno::ETIMEDOUT
+        true
+      end
+    end
+
+    def uri_open(*args)
+      (RbConfig::CONFIG['ruby_version'] < '2.7') ? open(*args) : URI.open(*args)
+    end
+
+    def write_url
+      # Make sure app dir is setup
+      FileUtils.mkdir_p(app_dir)
+      File.open(url_file, 'w') {|f| f << url }
+    end
+
+    def check_for_running(path = nil)
+      if File.exist?(pid_file) && File.exist?(url_file)
+        running_url = File.read(url_file)
+        if !port_open?(running_url)
+          logger.warn "'#{app_name}' is already running at #{running_url}"
+          launch!(running_url, path)
+          exit!(1)
+        end
+      end
+    end
+
+    def run!
+      logger.info "Running with Rack handler: #{@rack_handler.inspect}"
+
+      rack_handler.run app, :Host => host, :Port => port do |server|
+        kill_commands.each do |command|
+          trap(command) do
+            ## Use thins' hard #stop! if available, otherwise just #stop
+            server.respond_to?(:stop!) ? server.stop! : server.stop
+            logger.info "'#{app_name}' received INT ... stopping"
+            delete_pid!
+          end
+        end
+      end
+    end
+
+    # Adapted from Rackup
+    def daemonize!
+      if JRUBY
+        # It's not a true daemon but when executed with & works like one
+        thread = Thread.new {daemon_execute}
+        thread.join
+
+      elsif RUBY_VERSION < "1.9"
+        logger.debug "Parent Process: #{Process.pid}"
+        exit!(0) if fork
+        logger.debug "Child Process: #{Process.pid}"
+        daemon_execute
+
+      else
+        Process.daemon(true, true)
+        daemon_execute
+      end
+    end
+
+    def daemon_execute
+      File.umask 0000
+      FileUtils.touch log_file
+      STDIN.reopen    log_file
+      STDOUT.reopen   log_file, "a"
+      STDERR.reopen   log_file, "a"
+
+      logger.debug "Child Process: #{Process.pid}"
+
+      File.open(pid_file, 'w') {|f| f.write("#{Process.pid}") }
+      at_exit { delete_pid! }
+    end
+
+    def launch!(specific_url = nil, path = nil)
+      return if options[:skip_launch]
+      cmd = WINDOWS ? "start" : "open"
+      system "#{cmd} #{specific_url || url}#{path}"
+    end
+
+    def kill!
+      pid = File.read(pid_file)
+      logger.warn "Sending #{kill_command} to #{pid.to_i}"
+      Process.kill(kill_command, pid.to_i)
+    rescue => e
+      logger.warn "pid not found at #{pid_file} : #{e}"
+    end
+
+    def status
+      if File.exists?(pid_file)
+        logger.info "'#{app_name}' running"
+        logger.info "PID #{File.read(pid_file)}"
+        logger.info "URL #{File.read(url_file)}" if File.exists?(url_file)
+      else
+        logger.info "'#{app_name}' not running!"
+      end
+    end
+
+    # Loads a config file at config_path and evals it in the context of the @app.
+    def load_config_file(config_path)
+      abort "Can not find config file at #{config_path}" if !File.readable?(config_path)
+      config = File.read(config_path)
+      # trim off anything after __END__
+      config.sub!(/^__END__\n.*/, '')
+      @app.module_eval(config)
+    end
+
+    def self.logger=(logger)
+      @logger = logger
+    end
+
+    def self.logger
+      @logger ||= LOGGER if defined?(LOGGER)
+      if !@logger
+        @logger           = Logger.new(STDOUT)
+        @logger.formatter = Proc.new {|s, t, n, msg| "[#{t}] #{msg}\n"}
+        @logger
+      end
+      @logger
+    end
+
+    def logger
+      self.class.logger
+    end
+
+  private
+    def setup_rack_handler
+      # First try to set Rack handler via a special hook we honor
+      @rack_handler = if @app.respond_to?(:detect_rack_handler)
+        @app.detect_rack_handler
+
+      # If they aren't using our hook, try to use their @app.server settings
+      elsif @app.respond_to?(:server) and @app.server
+        # If :server isn't set, it returns an array of possibilities,
+        # sorted from most to least preferable.
+        if @app.server.is_a?(Array)
+          handler = nil
+          @app.server.each do |server|
+            begin
+              handler = Rack::Handler.get(server)
+              break
+            rescue LoadError, NameError => e
+              next
+            end
+          end
+          handler
+
+        # :server might be set explicitly to a single option like "mongrel"
+        else
+          Rack::Handler.get(@app.server)
+        end
+
+      # If all else fails, we'll use Thin
+      else
+        JRUBY ? Rack::Handler::WEBrick : Rack::Handler::Thin
+      end
+    end
+
+    def load_options(runtime_args)
+      @args = option_parser.parse!(runtime_args)
+      options.merge!(option_parser.options)
+      args
+    rescue OptionParser::MissingArgument => e
+      logger.warn "#{e}, run -h for options"
+      exit
+    end
+
+    def option_parser
+      @option_parser ||= Parser.new(app_name)
+    end
+
+    class Parser < OptionParser
+      attr_reader :command, :options
+
+      def initialize(app_name)
+        super("", 24, '  ')
+        self.banner = "Usage: #{app_name} [options]"
+
+        @options = {}
+        basename = app_name.gsub(/\W+/, "_")
+        on('-K', "--kill", "kill the running process and exit") { @command = :kill }
+        on('-S', "--status", "display the current running PID and URL then quit") { @command = :status }
+        string_option("-s", "--server SERVER", "serve using SERVER (thin/mongrel/webrick)", :rack_handler)
+        string_option("-o", "--host HOST", "listen on HOST (default: #{HOST})", :host)
+        string_option("-p", "--port PORT", "use PORT (default: #{PORT})", :port)
+        on("-x", "--no-proxy", "ignore env proxy settings (e.g. http_proxy)") { opts[:no_proxy] = true }
+        boolean_option("-F", "--foreground", "don't daemonize, run in the foreground", :foreground)
+        boolean_option("-L", "--no-launch", "don't launch the browser", :skip_launch)
+        boolean_option('-d', "--debug", "raise the log level to :debug (default: :info)", :debug)
+        string_option("--app-dir APP_DIR", "set the app dir where files are stored (default: ~/#{basename}/)", :app_dir)
+        string_option("-P", "--pid-file PID_FILE", "set the path to the pid file (default: app_dir/#{basename}.pid)", :pid_file)
+        string_option("--log-file LOG_FILE", "set the path to the log file (default: app_dir/#{basename}.log)", :log_file)
+        string_option("--url-file URL_FILE", "set the path to the URL file (default: app_dir/#{basename}.url)", :url_file)
+        string_option('-N NAMESPACE', "--namespace NAMESPACE", "set the Redis namespace", :redis_namespace)
+        string_option('-r redis-connection', "--redis redis-connection", "set the Redis connection string", :redis_conf)
+        string_option('-a url-prefix', "--append url-prefix", "set reverse_proxy friendly prefix to links", :url_prefix)
+        separator ""
+        separator "Common options:"
+        on_tail("-h", "--help", "Show this message") { @command = :help }
+        on_tail("--version", "Show version") { @command = :version }
+      end
+
+      def boolean_option(*argv)
+        k = argv.pop; on(*argv) { options[k] = true }
+      end
+
+      def string_option(*argv)
+        k = argv.pop; on(*argv) { |value| options[k] = value }
+      end
+    end
+
+    def kill_commands
+      WINDOWS ? [1] : [:INT, :TERM]
+    end
+
+    def kill_command
+      kill_commands[0]
+    end
+
+    def delete_pid!
+      File.delete(pid_file) if File.exist?(pid_file)
+    end
+  end
+
+end

data/lib/resque/worker.rb

@@ -180,9 +180,17 @@ module Resque
     WILDCARDS = ['*', '?', '{', '}', '[', ']'].freeze
 
     def queues=(queues)
-      queues = queues.empty? ? (ENV["QUEUES"] || ENV['QUEUE']).to_s.split(',') : queues
-      @queues = queues.map { |queue| queue.to_s.strip }
-      @has_dynamic_queues = WILDCARDS.any? {|char| @queues.join.include?(char) }
+      queues = (ENV["QUEUES"] || ENV['QUEUE']).to_s.split(',') if queues.empty?
+      queues = queues.map { |queue| queue.to_s.strip }
+
+      @skip_queues, @queues = queues.partition { |queue| queue.start_with?('!') }
+      @skip_queues.map! { |queue| queue[1..-1] }
+
+      # The behavior of `queues` is dependent on the value of `@has_dynamic_queues: if it's true, the method returns the result of filtering @queues with `glob_match`
+      # if it's false, the method returns @queues directly. Since `glob_match` will cause skipped queues to be filtered out, we want to make sure it's called if we have @skip_queues.any?
+      @has_dynamic_queues =
+        @skip_queues.any? || WILDCARDS.any? { |char| @queues.join.include?(char) }
+
       validate_queues
     end
 
@@ -210,7 +218,8 @@ module Resque
 
     def glob_match(list, pattern)
       list.select do |queue|
-        File.fnmatch?(pattern, queue)
+        File.fnmatch?(pattern, queue) &&
+          @skip_queues.none? { |skip_pattern| File.fnmatch?(skip_pattern, queue) }
       end.sort
     end
 
@@ -570,7 +579,7 @@ module Resque
 
     # are we paused?
     def paused?
-      @paused
+      @paused || redis.get('pause-all-workers').to_s.strip.downcase == 'true'
     end
 
     # Stop processing jobs after the current one has completed (if we're
@@ -688,9 +697,9 @@ module Resque
 
       kill_background_threads
 
-      data_store.unregister_worker(self) do
-        Stat.clear("processed:#{self}")
-        Stat.clear("failed:#{self}")
+      data_store.unregister_worker(self) do |**opts|
+        Stat.clear("processed:#{self}", **opts)
+        Stat.clear("failed:#{self}",    **opts)
       end
     rescue Exception => exception_while_unregistering
       message = exception_while_unregistering.message
@@ -717,8 +726,8 @@ module Resque
     # Called when we are done working - clears our `working_on` state
     # and tells Redis we processed a job.
     def done_working
-      data_store.worker_done_working(self) do
-        processed!
+      data_store.worker_done_working(self) do |**opts|
+        processed!(**opts)
       end
     end
 
@@ -736,9 +745,9 @@ module Resque
     end
 
     # Tell Redis we've processed a job.
-    def processed!
-      Stat << "processed"
-      Stat << "processed:#{self}"
+    def processed!(**opts)
+      Stat.incr("processed",         1, **opts)
+      Stat.incr("processed:#{self}", 1, **opts)
     end
 
     # How many failed jobs has this worker seen? Returns an int.
@@ -852,7 +861,7 @@ module Resque
       `ps -A -o pid,comm | grep "[r]uby" | grep -v "resque-web"`.split("\n").map do |line|
         real_pid = line.split(' ')[0]
         pargs_command = `pargs -a #{real_pid} 2>/dev/null | grep [r]esque | grep -v "resque-web"`
-        if pargs_command.split(':')[1] == " resque-#{Resque::Version}"
+        if pargs_command.split(':')[1] == " resque-#{Resque::VERSION}"
           real_pid
         end
       end.compact
@@ -862,7 +871,7 @@ module Resque
     # Procline is always in the format of:
     #   RESQUE_PROCLINE_PREFIXresque-VERSION: STRING
     def procline(string)
-      $0 = "#{ENV['RESQUE_PROCLINE_PREFIX']}resque-#{Resque::Version}: #{string}"
+      $0 = "#{ENV['RESQUE_PROCLINE_PREFIX']}resque-#{Resque::VERSION}: #{string}"
       log_with_severity :debug, $0
     end
 

data/lib/resque.rb

@@ -23,7 +23,7 @@ require 'resque/thread_signal'
 
 require 'resque/vendor/utf8_util'
 
-require 'resque/railtie' if defined?(Rails)
+require 'resque/railtie' if defined?(Rails::Railtie)
 
 module Resque
   include Helpers
@@ -364,8 +364,8 @@ module Resque
     data_store.queue_size(queue)
   end
 
-  # Returns an array of items currently queued. Queue name should be
-  # a string.
+  # Returns an array of items currently queued, or the item itself
+  # if count = 1. Queue name should be a string.
   #
   # start and count should be integer and can be used for pagination.
   # start is the item to begin, count is how many items to return.
@@ -584,9 +584,9 @@ module Resque
   def queue_sizes
     queue_names = queues
 
-    sizes = redis.pipelined do
+    sizes = redis.pipelined do |piped|
       queue_names.each do |name|
-        redis.llen("queue:#{name}")
+        piped.llen("queue:#{name}")
       end
     end
 
@@ -597,11 +597,11 @@ module Resque
   def sample_queues(sample_size = 1000)
     queue_names = queues
 
-    samples = redis.pipelined do
+    samples = redis.pipelined do |piped|
       queue_names.each do |name|
         key = "queue:#{name}"
-        redis.llen(key)
-        redis.lrange(key, 0, sample_size - 1)
+        piped.llen(key)
+        piped.lrange(key, 0, sample_size - 1)
       end
     end
 

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: resque
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Chris Wanstrath
 - Steve Klabnik
 - Terence Lee
-autorequire:
+- Michael Bianco
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-10 00:00:00.000000000 Z
+date: 2022-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-namespace
@@ -26,20 +27,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
-- !ruby/object:Gem::Dependency
-  name: vegas
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: sinatra
   requirement: !ruby/object:Gem::Requirement
@@ -82,6 +69,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |2
       Resque is a Redis-backed Ruby library for creating background jobs,
       placing those jobs on multiple queues, and processing them later.
@@ -162,14 +177,17 @@ files:
 - lib/resque/thread_signal.rb
 - lib/resque/vendor/utf8_util.rb
 - lib/resque/version.rb
+- lib/resque/web_runner.rb
 - lib/resque/worker.rb
 - lib/tasks/redis.rake
 - lib/tasks/resque.rake
-homepage: http://resque.github.io/
+homepage: https://github.com/resque/resque
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  changelog_uri: https://github.com/resque/resque/blob/master/HISTORY.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
 rdoc_options:
 - "--charset=UTF-8"
 require_paths:
@@ -185,8 +203,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key:
+rubygems_version: 3.3.5
+signing_key: 
 specification_version: 4
 summary: Resque is a Redis-backed queueing system.
 test_files: []