resque 2.2.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6f395169f58a51122135f8cbf6495ca914a472a94038277d6d022ac1387459a
-  data.tar.gz: ba5b39c8521b48b0f882c2290d105dc8b2db24308cf08d14d630841ed45585ed
+  metadata.gz: 42bdd72240bcf206aa094dc525eca1747b51f4456ed28ae562ceccb10c4f313f
+  data.tar.gz: 44297a31bb61f835b6acbba5195f77826b1d476611169f47ebfa07fbae7df1f3
 SHA512:
-  metadata.gz: f03920bbf92a185a5d6c062d9d10dbc17c8b3090ed9bbd04138e85b3a40f0cefa377c21f22a343c3c9b64cd3502998efa5b42f5a6f6c7f314712ceb54bc9671e
-  data.tar.gz: af2ac4eb41bd9dc30951fd1122deada0b445000736ff08a020313e4337655c61e79af888e7b21e3c6c1cacab2e3bc5cc1f4d28577d2e2e02e62c5f8bf3452a18
+  metadata.gz: 76d9e121e971b063d1ca1b6207c9a867cc3c97731197167fc2e4dacf8ff76d92857a5bf3a7d61f22f4d6a8eb2c216c519b5ba4ce7e0fbf728c386e0e96f073a3
+  data.tar.gz: b36861b666b72c962b12c35fb8214931a49e422886b03e29ee718dad831114a4ff475a36153997787c01c6d451ca202d34c1d8b563b9a657f5a2447e5e24b2b3

data/HISTORY.md

@@ -2,13 +2,19 @@
 
 ### Fixed
 
-*
-*
+### Added
+
+## 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
 

data/README.markdown

@@ -4,9 +4,7 @@ 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)
 
-Resque (pronounced like "rescue") is a Redis-backed library for creating
-background jobs, placing those jobs on multiple queues, and processing
-them later.
+Resque is a Redis-backed queueing system.
 
 ---------
 ### Note on the future of this repo
@@ -17,39 +15,12 @@ on just that topic, so please feel free to join in. We'd love to hear your thoug
 and/or have people volunteer to be a part of the project!
 
 ---------
-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
-can do both.
-
-Resque is heavily inspired by DelayedJob (which rocks) and comprises
-three parts:
-
-1. A Ruby library for creating, querying, and processing jobs
-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 queues are persistent; support constant time, atomic push and
-pop (thanks to Redis); provide visibility into their contents; and
-store jobs as simple JSON packages.
-
-The Resque frontend tells you what workers are doing, what workers are
-not doing, what queues you're using, what's in those queues, provides
-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.
-
 
 Table of Contents
 -----------------
 
-* [Overview](#overview)
+* [Introduction](#introduction)
+* [Example](#example)
 * [Installation](#installation)
 * [Running Workers](#running-workers)
 * [The Front End](#the-front-end)
@@ -74,13 +45,46 @@ Table of Contents
 * [Meta](#meta)
 * [Author](#author)
 
-Overview
---------
+Introduction
+------------
+
+Resque (pronounced like "rescue") is a Redis-backed library for creating
+background jobs, placing those jobs on multiple queues, and processing
+them later.
+
+For the backstory, philosophy, and history of Resque's beginnings, please see [the blog post](http://github.com/blog/542-introducing-resque) (2009).
 
-For the backstory, philosophy, and history of Resque's beginnings, please see [the blog post](http://github.com/blog/542-introducing-resque).
+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
+can do both.
 
-Resque allows you to create jobs and place them on a queue, then,
-later, pull those jobs off the queue and process them.
+Resque is heavily inspired by DelayedJob (which rocks) and comprises
+three parts:
+
+1. A Ruby library for creating, querying, and processing jobs
+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  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
+store jobs as simple JSON packages.
+
+The Resque frontend tells you what workers are doing, what workers are
+not doing, what queues you're using, what's in those queues, provides
+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.
+
+Example
+-------
 
 Resque jobs are Ruby classes (or modules) which respond to the
 `perform` method. Here's an example:
@@ -140,10 +144,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 +165,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 +253,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 +347,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 +703,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:
@@ -770,7 +792,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 +883,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/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,12 +1,12 @@
 <% 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] %>
@@ -15,7 +15,7 @@
   </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/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

data/lib/resque/version.rb

@@ -1,3 +1,3 @@
 module Resque
-  VERSION = '2.2.0'
+  VERSION = '2.2.1'
 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 (namespace = options[:redis_namespace])
+        runner.logger.info "Using Redis namespace '#{namespace}'"
+        Resque.redis.namespace = namespace
+      end
+      if (redis_conf = options[:redis_conf])
+        logger.info "Using Redis connection '#{redis_conf}'"
+        Resque.redis = redis_conf
+      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
 

data/lib/resque.rb

@@ -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.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Chris Wanstrath
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-04 00:00:00.000000000 Z
+date: 2022-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-namespace
@@ -27,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
@@ -83,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.
@@ -163,6 +177,7 @@ 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