resqued 0.0.1

data/README.md

@@ -0,0 +1,66 @@
+# resqued - a long-running daemon for resque workers.
+
+[image of a ninja rescuing an ear of corn]
+
+resqued provides a resque worker that works well with
+slow jobs and continuous delivery.
+
+## Installation
+
+Install by adding resqued to your Gemfile
+
+    gem 'resqued'
+
+## Set up
+
+Let's say you were running workers like this:
+
+    rake resque:work QUEUE=high        &
+    rake resque:work QUEUE=high        &
+    rake resque:work QUEUE=slow        &
+    rake resque:work QUEUE=medium      &
+    rake resque:work QUEUE=medium,low  &
+
+To run the same fleet of workers with resqued, create a config file
+`config/resqued.rb` like this:
+
+    base = File.expand_path('..', File.dirname(__FILE__))
+    pidfile File.join(base, 'tmp/pids/resqued-listener.pid')
+
+    worker do
+      workers 2
+      queue 'high'
+    end
+
+    worker do
+      queue 'slow'
+      timeout -1 # never time out
+    end
+
+    worker do
+      queue 'medium'
+    end
+
+    worker do
+      queues 'medium', 'low'
+    end
+
+Run it like this:
+
+    resqued config/resqued.rb
+
+Or like this to daemonize it:
+
+    resqued -p tmp/pids/resqued-master.pid -D config/resqued.rb
+
+When resqued is running, it has the following processes:
+
+* master - brokers signals to child processes.
+* queue reader - retrieves jobs from queues and forks worker processes.
+* worker - runs a single job.
+
+The following signals are handled by the resqued master process:
+
+* HUP - reread config file and gracefully restart all workers.
+* INT / TERM - immediately kill all workers and shut down.
+* QUIT - graceful shutdown. Waits for workers to finish.

data/exe/resqued

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+options = {}
+daemonize = false
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: resqued [options] resqued-config-file"
+
+  opts.on '-h', '--help', 'Show this message' do
+    puts opts
+    exit
+  end
+
+  opts.on '-v', '--version', 'Show the version' do
+    require 'resqued/version'
+    puts Resqued::VERSION
+    exit
+  end
+
+  opts.on '-p', '--pidfile PIDFILE', 'Store the pid of the master process in PIDFILE' do |v|
+    options[:master_pidfile] = v
+  end
+
+  opts.on '-l', '--logfile LOGFILE', 'Write output to LOGFILE instead of stdout' do |v|
+    require 'resqued/logging'
+    Resqued::Logging.log_file = v
+  end
+
+  opts.on '-D', '--daemonize', 'Run daemonized in the background' do
+    daemonize = true
+  end
+end
+
+opts.parse!
+
+unless options[:config_path] = ARGV[0]
+  puts opts
+  exit 1
+end
+
+require 'resqued/master'
+resqued = Resqued::Master.new(options)
+if daemonize
+  require 'resqued/daemon'
+  resqued = Resqued::Daemon.new(resqued)
+end
+resqued.run

data/exe/resqued-listener

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'resqued/listener'
+Resqued::Listener.exec!

data/lib/resqued/backoff.rb

@@ -0,0 +1,46 @@
+module Resqued
+  class Backoff
+    def initialize(options = {})
+      @time = options.fetch(:time) { Time }
+      @min  = options.fetch(:min) { 1.0 }
+      @max  = options.fetch(:max) { 16.0 }
+    end
+
+    # Public: Tell backoff that the thing we might want to back off from just started.
+    def started
+      @last_started_at = now
+      @backoff_duration = @backoff_duration ? [@backoff_duration * 2.0, @max].min : @min
+    end
+
+    def finished
+      @backoff_duration = nil if ok?
+    end
+
+    # Public: Check if we should wait before starting again.
+    def wait?
+      @last_started_at && next_start_at > now
+    end
+
+    # Public: Check if we are ok to start (i.e. we don't need to back off).
+    def ok?
+      ! wait?
+    end
+
+    # Public: How much longer until `ok?` will be true?
+    def how_long?
+      ok? ? nil : next_start_at - now
+    end
+
+    private
+
+    # Private: The next time when you're allowed to start a process.
+    def next_start_at
+      @last_started_at && @backoff_duration ? @last_started_at + @backoff_duration : now
+    end
+
+    # Private.
+    def now
+      @time.now
+    end
+  end
+end

data/lib/resqued/config.rb

@@ -0,0 +1,88 @@
+module Resqued
+  class Config
+    # Public: Build a new config instance from the given file.
+    def self.load_file(filename)
+      new.load_file(filename)
+    end
+
+    # Public: Build a new config instance from the given `config` script.
+    def self.load_string(config, filename = nil)
+      new.load_string(config, filename)
+    end
+
+    # Public: Build a new config instance.
+    def initialize
+      @workers = []
+    end
+
+    # Public: The configured pidfile path, or nil.
+    attr_reader :pidfile
+    
+    # Public: An array of configured workers.
+    attr_reader :workers
+
+    # Public: Add to this config using the script `config`.
+    def load_string(config, filename = nil)
+      DSL.new(self)._apply(config, filename)
+      self
+    end
+
+    # Public: Add to this config using the script in the given file.
+    def load_file(filename)
+      load_string(File.read(filename), filename)
+    end
+
+    # Private.
+    class DSL
+      def initialize(config)
+        @config = config
+      end
+
+      # Internal.
+      def _apply(script, filename)
+        if filename.nil?
+          instance_eval(script)
+        else
+          instance_eval(script, filename)
+        end
+      end
+
+      # Public: Set the pidfile path.
+      def pidfile(path)
+        raise ArgumentError unless path.is_a?(String)
+        _set(:pidfile, path)
+      end
+
+      # Public: Define a worker.
+      def worker
+        @current_worker = {:size => 1, :queues => []}
+        yield
+        _push(:workers, @current_worker)
+        @current_worker = nil
+      end
+
+      # Public: Add queues to a worker
+      def queues(*queues)
+        queues = [queues].flatten.map { |q| q.to_s }
+        @current_worker[:queues] += queues
+      end
+      alias queue queues
+
+      # Public: Set the number of workers
+      def workers(count)
+        raise ArgumentError unless count.is_a?(Fixnum)
+        @current_worker[:size] = count
+      end
+
+      # Private.
+      def _set(instance_variable, value)
+        @config.instance_variable_set("@#{instance_variable}", value)
+      end
+
+      # Private.
+      def _push(instance_variable, value)
+        @config.instance_variable_get("@#{instance_variable}").push(value)
+      end
+    end
+  end
+end

data/lib/resqued/daemon.rb

@@ -0,0 +1,30 @@
+module Resqued
+  class Daemon
+    def initialize(master)
+      @master = master
+    end
+
+    # Public: daemonize and run the master process.
+    def run
+      rd, wr = IO.pipe
+      if fork
+        # grandparent
+        wr.close
+        begin
+          master_pid = rd.readpartial(16).to_i
+          exit
+        rescue EOFError
+          puts "Master process failed to start!"
+          exit! 1
+        end
+      elsif fork
+        # parent
+        Process.setsid
+        exit
+      else
+        # master
+        @master.run(wr)
+      end
+    end
+  end
+end

data/lib/resqued/listener.rb

@@ -0,0 +1,221 @@
+require 'socket'
+
+require 'resqued/config'
+require 'resqued/logging'
+require 'resqued/pidfile'
+require 'resqued/sleepy'
+require 'resqued/worker'
+
+module Resqued
+  # A listener process. Watches resque queues and forks workers.
+  class Listener
+    include Resqued::Logging
+    include Resqued::Pidfile
+    include Resqued::Sleepy
+
+    # Configure a new listener object.
+    def initialize(options)
+      @config_path     = options.fetch(:config_path)
+      @running_workers = options.fetch(:running_workers) { [] }
+      @socket          = options.fetch(:socket)
+      @listener_id     = options.fetch(:listener_id) { nil }
+    end
+
+    # Public: As an alternative to #run, exec a new ruby instance for this listener.
+    def exec
+      ENV['RESQUED_SOCKET']      = @socket.fileno.to_s
+      ENV['RESQUED_CONFIG_PATH'] = @config_path
+      ENV['RESQUED_STATE']       = (@running_workers.map { |r| "#{r[:pid]}|#{r[:queue]}" }.join('||'))
+      ENV['RESQUED_LISTENER_ID'] = @listener_id.to_s
+      Kernel.exec('resqued-listener')
+    end
+
+    # Public: Given args from #exec, start this listener.
+    def self.exec!
+      options = {}
+      if socket = ENV['RESQUED_SOCKET']
+        options[:socket] = Socket.for_fd(socket.to_i)
+      end
+      if path = ENV['RESQUED_CONFIG_PATH']
+        options[:config_path] = path
+      end
+      if state = ENV['RESQUED_STATE']
+        options[:running_workers] = state.split('||').map { |s| Hash[[:pid,:queue].zip(s.split('|'))] }
+      end
+      if listener_id = ENV['RESQUED_LISTENER_ID']
+        options[:listener_id] = listener_id
+      end
+      new(options).run
+    end
+
+    # Private: memoizes the worker configuration.
+    def config
+      @config ||= Config.load_file(@config_path)
+    end
+
+    SIGNALS = [ :QUIT ]
+
+    SIGNAL_QUEUE = []
+
+    # Public: Run the main loop.
+    def run
+      trap(:CHLD) { awake }
+      SIGNALS.each { |signal| trap(signal) { SIGNAL_QUEUE << signal ; awake } }
+      @socket.close_on_exec = true
+
+      with_pidfile(config.pidfile) do
+        write_procline('running')
+        load_environment
+        init_workers
+        run_workers_run
+      end
+
+      write_procline('shutdown')
+      burn_down_workers(:QUIT)
+    end
+
+    # Private.
+    def run_workers_run
+      loop do
+        reap_workers(Process::WNOHANG)
+        check_for_expired_workers
+        start_idle_workers
+        case signal = SIGNAL_QUEUE.shift
+        when nil
+          yawn
+        when :QUIT
+          return
+        end
+      end
+    end
+
+    # Private: make sure all the workers stop.
+    #
+    # Resque workers have gaps in their signal-handling ability.
+    def burn_down_workers(signal)
+      loop do
+        check_for_expired_workers
+        SIGNAL_QUEUE.clear
+
+        break if :no_child == reap_workers(Process::WNOHANG)
+
+        log "kill -#{signal} #{running_workers.map { |r| r.pid }.inspect}"
+        running_workers.each { |worker| worker.kill(signal) }
+
+        sleep 1 # Don't kill any more often than every 1s.
+        yawn 5
+      end
+      # One last time.
+      reap_workers
+    end
+
+    # Private: all available workers
+    attr_reader :workers
+
+    # Private: just the running workers.
+    def running_workers
+      workers.select { |worker| ! worker.idle? }
+    end
+
+    # Private.
+    def yawn(sleep_time = nil)
+      sleep_time ||=
+        begin
+          sleep_times = [60.0] + workers.map { |worker| worker.backing_off_for }
+          [sleep_times.compact.min, 0.0].max
+        end
+      super(sleep_time, @socket)
+    end
+
+    # Private: Check for workers that have stopped running
+    def reap_workers(waitpidflags = 0)
+      loop do
+        worker_pid, status = Process.waitpid2(-1, waitpidflags)
+        return :none_ready if worker_pid.nil?
+        finish_worker(worker_pid, status)
+        report_to_master("-#{worker_pid}")
+      end
+    rescue Errno::ECHILD
+      # All done
+      :no_child
+    end
+
+    # Private: Check if master reports any dead workers.
+    def check_for_expired_workers
+      loop do
+        IO.select([@socket], nil, nil, 0) or return
+        line = @socket.readline
+        finish_worker(line.to_i, nil)
+      end
+    rescue EOFError
+      log "eof from master"
+      Process.kill(:QUIT, $$)
+    end
+
+    # Private.
+    def finish_worker(worker_pid, status)
+      workers.each do |worker|
+        if worker.pid == worker_pid
+          worker.finished!(status)
+        end
+      end
+    end
+
+    # Private.
+    def start_idle_workers
+      workers.each do |worker|
+        if worker.idle?
+          worker.try_start
+          if pid = worker.pid
+            report_to_master("+#{pid},#{worker.queue_key}")
+          end
+        end
+      end
+    end
+
+    # Private.
+    def init_workers
+      workers = []
+      config.workers.each do |worker_config|
+        worker_config[:size].times do
+          workers << Worker.new(worker_config)
+        end
+      end
+      @running_workers.each do |running_worker|
+        if blocked_worker = workers.detect { |worker| worker.idle? && worker.queue_key == running_worker[:queue] }
+          blocked_worker.wait_for(running_worker[:pid].to_i)
+        end
+      end
+      @workers = workers
+    end
+
+    # Private: Report child process status.
+    #
+    # Examples:
+    #
+    #     report_to_master("+12345,queue")  # Worker process PID:12345 started, working on a job from "queue".
+    #     report_to_master("-12345")        # Worker process PID:12345 exited.
+    def report_to_master(status)
+      @socket.puts(status)
+    end
+
+    # Private: load the application.
+    #
+    # To do:
+    # * Does this reload correctly if the bundle changes and `bundle exec resqued config/resqued.rb`?
+    # * Maybe make the specific app environment configurable (i.e. load rails, load rackup, load some custom thing)
+    def load_environment
+      require File.expand_path('config/environment.rb')
+      Rails.application.eager_load!
+    end
+
+    # Private.
+    def write_procline(status)
+      procline = "resqued listener"
+      procline << " #{@listener_id}" if @listener_id
+      procline << " [#{status}]"
+      procline << " #{@config_path}"
+      $0 = procline
+    end
+  end
+end

data/lib/resqued/listener_proxy.rb

@@ -0,0 +1,98 @@
+require 'fcntl'
+require 'socket'
+
+require 'resqued/listener'
+require 'resqued/logging'
+
+module Resqued
+  class ListenerProxy
+    include Resqued::Logging
+
+    # Public.
+    def initialize(options)
+      @options = options
+    end
+
+    # Public: wrap up all the things, this object is going home.
+    def dispose
+      if @master_socket
+        @master_socket.close
+        @master_socket = nil
+      end
+    end
+
+    # Public: An IO to select on to check if there is incoming data available.
+    def read_pipe
+      @master_socket
+    end
+
+    # Public: The pid of the running listener process.
+    attr_reader :pid
+
+    # Public: Start the listener process.
+    def run
+      return if pid
+      listener_socket, master_socket = UNIXSocket.pair
+      if @pid = fork
+        # master
+        listener_socket.close
+        master_socket.close_on_exec = true
+        log "Started listener #{@pid}"
+        @master_socket = master_socket
+      else
+        # listener
+        master_socket.close
+        Master::SIGNALS.each { |signal| trap(signal, 'DEFAULT') }
+        Listener.new(@options.merge(:socket => listener_socket)).exec
+        exit
+      end
+    end
+
+    # Public: Stop the listener process.
+    def kill(signal)
+      log "kill -#{signal} #{pid}"
+      Process.kill(signal.to_s, pid)
+    end
+
+    # Public: Get the list of workers running from this listener.
+    def running_workers
+      worker_pids.map { |pid, queue| { :pid => pid, :queue => queue } }
+    end
+
+    # Private: Map worker pids to queue names
+    def worker_pids
+      @worker_pids ||= {}
+    end
+
+    # Public: Check for updates on running worker information.
+    def read_worker_status(options)
+      on_finished = options[:on_finished]
+      until @master_socket.nil?
+        IO.select([@master_socket], nil, nil, 0) or return
+        line = @master_socket.readline
+        if line =~ /^\+(\d+),(.*)$/
+          worker_pids[$1] = $2
+        elsif line =~ /^-(\d+)$/
+          worker_pids.delete($1)
+          on_finished.worker_finished($1) if on_finished
+        elsif line == ''
+          break
+        else
+          log "Malformed data from listener: #{line.inspect}"
+        end
+      end
+    rescue EOFError
+      @master_socket.close
+      @master_socket = nil
+    end
+
+    # Public: Tell the listener process that a worker finished.
+    def worker_finished(pid)
+      return if @master_socket.nil?
+      @master_socket.puts(pid)
+    rescue Errno::EPIPE
+      @master_socket.close
+      @master_socket = nil
+    end
+  end
+end

data/lib/resqued/logging.rb

@@ -0,0 +1,37 @@
+module Resqued
+  module Logging
+    # Public.
+    def self.log_file=(path)
+      ENV['RESQUED_LOGFILE'] = File.expand_path(path)
+    end
+
+    # Public.
+    def self.log_file
+      ENV['RESQUED_LOGFILE']
+    end
+
+    # Public.
+    def log_to_stdout?
+      Resqued::Logging.log_file.nil?
+    end
+
+    # Private (in classes that include this module)
+    def log(message)
+      logging_io.puts "[#{$$} #{Time.now.strftime('%H:%M:%S')}] #{message}"
+    end
+
+    # Private (may be overridden in classes that include this module to send output to a different IO)
+    def logging_io
+      @logging_io = nil if @logging_io && @logging_io.closed?
+      @logging_io ||=
+        if path = Resqued::Logging.log_file
+          File.open(path, 'a').tap do |f|
+            f.sync = true
+            f.close_on_exec = true
+          end
+        else
+          $stdout
+        end
+    end
+  end
+end

data/lib/resqued/master.rb

@@ -0,0 +1,195 @@
+require 'resqued/backoff'
+require 'resqued/listener_proxy'
+require 'resqued/logging'
+require 'resqued/pidfile'
+require 'resqued/sleepy'
+
+module Resqued
+  # The master process.
+  # * Spawns a listener.
+  # * Tracks all work. (IO pipe from listener.)
+  # * Handles signals.
+  class Master
+    include Resqued::Logging
+    include Resqued::Pidfile
+    include Resqued::Sleepy
+
+    def initialize(options)
+      @config_path = options.fetch(:config_path)
+      @pidfile     = options.fetch(:master_pidfile) { nil }
+      @listener_backoff = Backoff.new
+      @listeners_created = 0
+    end
+
+    # Public: Starts the master process.
+    def run(ready_pipe = nil)
+      report_unexpected_exits
+      with_pidfile(@pidfile) do
+        write_procline
+        install_signal_handlers
+        if ready_pipe
+          ready_pipe.syswrite($$.to_s)
+          ready_pipe.close rescue nil
+        end
+        go_ham
+      end
+      no_more_unexpected_exits
+    end
+
+    # Private: dat main loop.
+    def go_ham
+      loop do
+        read_listeners
+        reap_all_listeners(Process::WNOHANG)
+        start_listener
+        case signal = SIGNAL_QUEUE.shift
+        when nil
+          yawn(@listener_backoff.how_long? || 30.0)
+        when :INFO
+          dump_object_counts
+        when :HUP
+          log "Restarting listener with new configuration and application."
+          kill_listener(:QUIT)
+        when :INT, :TERM, :QUIT
+          log "Shutting down..."
+          kill_all_listeners(signal)
+          wait_for_workers
+          break
+        end
+      end
+    end
+
+    # Private.
+    def dump_object_counts
+      log GC.stat.inspect
+      counts = {}
+      total = 0
+      ObjectSpace.each_object do |o|
+        count = counts[o.class.name] || 0
+        counts[o.class.name] = count + 1
+        total += 1
+      end
+      top = 10
+      log "#{total} objects. top #{top}:"
+      counts.sort_by { |name, count| count }.reverse.each_with_index do |(name, count), i|
+        if i < top
+          diff = ""
+          if last = @last_counts && @last_counts[name]
+            diff = " (#{'%+d' % (count - last)})"
+          end
+          log "   #{count} #{name}#{diff}"
+        end
+      end
+      @last_counts = counts
+      log GC.stat.inspect
+    rescue => e
+      log "Error while counting objects: #{e}"
+    end
+
+    # Private: Map listener pids to ListenerProxy objects.
+    def listener_pids
+      @listener_pids ||= {}
+    end
+
+    # Private: All the ListenerProxy objects.
+    def all_listeners
+      listener_pids.values
+    end
+
+    attr_reader :config_path
+    attr_reader :pidfile
+
+    def start_listener
+      return if @current_listener || @listener_backoff.wait?
+      @current_listener = ListenerProxy.new(:config_path => @config_path, :running_workers => all_listeners.map { |l| l.running_workers }.flatten, :listener_id => next_listener_id)
+      @current_listener.run
+      @listener_backoff.started
+      listener_pids[@current_listener.pid] = @current_listener
+      write_procline
+    end
+
+    def next_listener_id
+      @listeners_created += 1
+    end
+
+    def read_listeners
+      all_listeners.each do |l|
+        l.read_worker_status(:on_finished => self)
+      end
+    end
+
+    def worker_finished(pid)
+      all_listeners.each do |other|
+        other.worker_finished(pid)
+      end
+    end
+
+    def kill_listener(signal)
+      if @current_listener
+        @current_listener.kill(signal)
+        @current_listener = nil
+      end
+    end
+
+    def kill_all_listeners(signal)
+      all_listeners.each do |l|
+        l.kill(signal)
+      end
+    end
+
+    def wait_for_workers
+      reap_all_listeners
+    end
+
+    def reap_all_listeners(waitpid_flags = 0)
+      begin
+        lpid, status = Process.waitpid2(-1, waitpid_flags)
+        if lpid
+          log "Listener exited #{status}"
+          if @current_listener && @current_listener.pid == lpid
+            @listener_backoff.finished
+            @current_listener = nil
+          end
+          listener_pids.delete(lpid).dispose # This may leak workers.
+          write_procline
+        else
+          return
+        end
+      rescue Errno::ECHILD
+        return
+      end while true
+    end
+
+    SIGNALS = [ :HUP, :INT, :TERM, :QUIT, :INFO ]
+
+    SIGNAL_QUEUE = []
+
+    def install_signal_handlers
+      trap(:CHLD) { awake }
+      SIGNALS.each { |signal| trap(signal) { SIGNAL_QUEUE << signal ; awake } }
+    end
+
+    def report_unexpected_exits
+      trap('EXIT') do
+        log("EXIT #{$!.inspect}")
+        if $!
+          $!.backtrace.each do |line|
+            log(line)
+          end
+        end
+      end
+    end
+
+    def no_more_unexpected_exits
+      trap('EXIT', nil)
+    end
+
+    def yawn(duration)
+      super(duration, all_listeners.map { |l| l.read_pipe })
+    end
+
+    def write_procline
+      $0 = "resqued master [gen #{@listeners_created}] [#{listener_pids.size} running] #{ARGV.join(' ')}"
+    end
+  end
+end

data/lib/resqued/pidfile.rb

@@ -0,0 +1,27 @@
+module Resqued
+  module Pidfile
+    def with_pidfile(filename)
+      write_pidfile(filename) if filename
+      yield
+    ensure
+      remove_pidfile(filename) if filename
+    end
+
+    def write_pidfile(filename)
+      pf =
+        begin
+          tmp = "#{filename}.#{rand}.#{$$}"
+          File.open(tmp, File::RDWR | File::CREAT | File::EXCL, 0644)
+        rescue Errno::EEXIST
+          retry
+        end
+      pf.syswrite("#{$$}\n")
+      File.rename(pf.path, filename)
+      pf.close
+    end
+
+    def remove_pidfile(filename)
+      (File.read(filename).to_i == $$) and File.unlink(filename) rescue nil
+    end
+  end
+end

data/lib/resqued/sleepy.rb

@@ -0,0 +1,20 @@
+require 'fcntl'
+require 'kgio'
+
+module Resqued
+  module Sleepy
+    def self_pipe
+      @self_pipe ||= Kgio::Pipe.new.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
+    end
+
+    def yawn(duration, *inputs)
+      inputs = [self_pipe[0]] + [inputs].flatten.compact
+      IO.select(inputs, nil, nil, duration) or return
+      self_pipe[0].kgio_tryread(11)
+    end
+
+    def awake
+      self_pipe[1].kgio_trywrite('.')
+    end
+  end
+end

data/lib/resqued/version.rb

@@ -0,0 +1,3 @@
+module Resqued
+  VERSION = '0.0.1'
+end

data/lib/resqued/worker.rb

@@ -0,0 +1,96 @@
+require 'resque'
+
+require 'resqued/backoff'
+require 'resqued/logging'
+
+module Resqued
+  # Models a worker process.
+  class Worker
+    include Resqued::Logging
+
+    def initialize(options)
+      @queues = options.fetch(:queues)
+      @backoff = Backoff.new
+    end
+
+    # Public: The pid of the worker process.
+    attr_reader :pid
+
+    # Private.
+    attr_reader :queues
+
+    # Public: True if there is no worker process mapped to this object.
+    def idle?
+      pid.nil?
+    end
+
+    # Public: Checks if this worker works on jobs from the queue.
+    def queue_key
+      queues.sort.join(';')
+    end
+
+    # Public: Claim this worker for another listener's worker.
+    def wait_for(pid)
+      raise "Already running #{@pid} (can't wait for #{pid})" if @pid
+      @self_started = nil
+      @pid = pid
+    end
+
+    # Public: The old worker process finished!
+    def finished!(process_status)
+      @pid = nil
+      @backoff.finished
+    end
+
+    # Public: The amount of time we need to wait before starting a new worker.
+    def backing_off_for
+      @pid ? nil : @backoff.how_long?
+    end
+
+    # Public: Start a job, if there's one waiting in one of my queues.
+    def try_start
+      return if @backoff.wait?
+      @backoff.started
+      @self_started = true
+      if @pid = fork
+        # still in the listener
+      else
+        # In case we get a signal before the process is all the way up.
+        [:QUIT, :TERM, :INT].each { |signal| trap(signal) { exit 1 } }
+        $0 = "STARTING RESQUE FOR #{queues.join(',')}"
+        if ! log_to_stdout?
+          lf = logging_io
+          if Resque.respond_to?("logger=")
+            Resque.logger = Resque.logger.class.new(lf)
+          else
+            $stdout.reopen(lf)
+            lf.close
+          end
+        end
+        resque_worker = Resque::Worker.new(*queues)
+        resque_worker.log "Starting worker #{resque_worker}"
+        resque_worker.term_child = true # Hopefully do away with those warnings!
+        resque_worker.work(5)
+        exit 0
+      end
+    end
+
+    # Public: Shut this worker down.
+    #
+    # We are using these signal semantics:
+    # HUP: restart (QUIT workers)
+    # INT/TERM: immediately exit
+    # QUIT: graceful shutdown
+    #
+    # Resque uses these (compatible) signal semantics:
+    # TERM: Shutdown immediately, stop processing jobs.
+    #  INT: Shutdown immediately, stop processing jobs.
+    # QUIT: Shutdown after the current job has finished processing.
+    # USR1: Kill the forked child immediately, continue processing jobs.
+    # USR2: Don't process any new jobs
+    # CONT: Start processing jobs again after a USR2
+    def kill(signal)
+      Process.kill(signal.to_s, pid) if pid && @self_started
+    end
+  end
+end

data/lib/resqued.rb

@@ -0,0 +1,2 @@
+require 'resqued/master'
+require 'resqued/version'

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: resqued
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matt Burke
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2013-08-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kgio
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.22.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.22.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.4.1
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Daemon of resque workers
+email: spraints@gmail.com
+executables:
+- resqued
+- resqued-listener
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/resqued/backoff.rb
+- lib/resqued/config.rb
+- lib/resqued/daemon.rb
+- lib/resqued/listener.rb
+- lib/resqued/listener_proxy.rb
+- lib/resqued/logging.rb
+- lib/resqued/master.rb
+- lib/resqued/pidfile.rb
+- lib/resqued/sleepy.rb
+- lib/resqued/version.rb
+- lib/resqued/worker.rb
+- lib/resqued.rb
+- README.md
+- exe/resqued
+- exe/resqued-listener
+homepage: https://github.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Daemon of resque workers
+test_files: []